Merge "Add internal TestViewConfiguration" into androidx-main
diff --git a/car/app/app-activity/src/main/java/androidx/car/app/activity/ActivityLifecycleDelegate.java b/car/app/app-activity/src/main/java/androidx/car/app/activity/ActivityLifecycleDelegate.java
index 66bad88..0df1174 100644
--- a/car/app/app-activity/src/main/java/androidx/car/app/activity/ActivityLifecycleDelegate.java
+++ b/car/app/app-activity/src/main/java/androidx/car/app/activity/ActivityLifecycleDelegate.java
@@ -32,7 +32,6 @@
* IRendererCallback}.
*/
final class ActivityLifecycleDelegate implements ActivityLifecycleCallbacks {
- public static final String TAG = "ActivityLifecycleListener";
@NonNull
private ServiceDispatcher mServiceDispatcher;
@Nullable
@@ -88,8 +87,7 @@
@Override
public void onActivityPreDestroyed(@NonNull Activity activity) {
- requireNonNull(activity);
- notifyEvent(Event.ON_DESTROY);
+ // No-op as the view model will call terminate on the service when needed.
}
@Override
diff --git a/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppActivity.java b/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppActivity.java
index f87ebec..1130a27 100644
--- a/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppActivity.java
+++ b/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppActivity.java
@@ -22,15 +22,10 @@
import android.annotation.SuppressLint;
import android.content.ComponentName;
-import android.content.Context;
import android.content.Intent;
-import android.content.ServiceConnection;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
-import android.content.pm.ResolveInfo;
import android.os.Bundle;
-import android.os.IBinder;
-import android.os.RemoteException;
import android.util.Log;
import android.view.View;
@@ -49,8 +44,7 @@
import androidx.car.app.serialization.BundlerException;
import androidx.car.app.utils.ThreadUtils;
import androidx.fragment.app.FragmentActivity;
-
-import java.util.List;
+import androidx.lifecycle.ViewModelProvider;
/**
* The class representing a car app activity.
@@ -96,20 +90,16 @@
public final class CarAppActivity extends FragmentActivity {
@VisibleForTesting
static final String SERVICE_METADATA_KEY = "androidx.car.app.CAR_APP_SERVICE";
- private static final String TAG = "CarAppActivity";
@SuppressLint({"ActionValue"})
@VisibleForTesting
static final String ACTION_RENDER = "android.car.template.host.RendererService";
- @Nullable
- private ComponentName mServiceComponentName;
TemplateSurfaceView mSurfaceView;
- SurfaceHolderListener mSurfaceHolderListener;
- ActivityLifecycleDelegate mActivityLifecycleDelegate;
- @Nullable
- OnBackPressedListener mOnBackPressedListener;
- ServiceDispatcher mServiceDispatcher;
+ @Nullable SurfaceHolderListener mSurfaceHolderListener;
+ @Nullable ActivityLifecycleDelegate mActivityLifecycleDelegate;
+ @Nullable OnBackPressedListener mOnBackPressedListener;
+ @Nullable CarAppViewModel mViewModel;
private int mDisplayId;
/**
@@ -121,7 +111,7 @@
Log.e(LogTags.TAG, "Service error: " + errorType, exception);
- unbindService();
+ requireNonNull(mViewModel).unbind();
ThreadUtils.runOnMain(() -> {
Log.d(LogTags.TAG, "Showing error fragment");
@@ -162,14 +152,16 @@
ThreadUtils.runOnMain(
() -> {
mSurfaceView.setOnCreateInputConnectionListener(editorInfo ->
- mServiceDispatcher.fetch(null, () ->
+ getServiceDispatcher().fetch(null, () ->
callback.onCreateInputConnection(
editorInfo)));
mOnBackPressedListener = () ->
- mServiceDispatcher.dispatch(callback::onBackPressed);
+ getServiceDispatcher().dispatch(callback::onBackPressed);
- mActivityLifecycleDelegate.registerRendererCallback(callback);
+ requireNonNull(mActivityLifecycleDelegate)
+ .registerRendererCallback(callback);
+ requireNonNull(mViewModel).setRendererCallback(callback);
});
}
@@ -177,7 +169,8 @@
public void setSurfaceListener(@NonNull ISurfaceListener listener) {
requireNonNull(listener);
ThreadUtils.runOnMain(
- () -> mSurfaceHolderListener.setSurfaceListener(listener));
+ () -> requireNonNull(mSurfaceHolderListener)
+ .setSurfaceListener(listener));
}
@Override
@@ -201,87 +194,41 @@
}
};
- /** The service connection for the renderer service. */
- private ServiceConnection mServiceConnectionImpl =
- new ServiceConnection() {
- @Override
- public void onServiceConnected(
- @NonNull ComponentName name, @NonNull IBinder service) {
- requireNonNull(name);
- requireNonNull(service);
- Log.i(LogTags.TAG, String.format("Host service %s is connected",
- name.flattenToShortString()));
- IRendererService rendererService = IRendererService.Stub.asInterface(service);
- if (rendererService == null) {
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_INCOMPATIBLE,
- new Exception("Failed to get IRenderService binder from host: "
- + name));
- return;
- }
-
- mServiceDispatcher.setRendererService(rendererService);
- verifyServiceVersion(rendererService);
- initializeService(rendererService);
- updateIntent(getIntent());
- }
-
- @Override
- public void onServiceDisconnected(@NonNull ComponentName name) {
- requireNonNull(name);
-
- // Connection lost, but it might reconnect.
- Log.w(LogTags.TAG, String.format("Host service %s is disconnected",
- name.flattenToShortString()));
- }
-
- @Override
- public void onBindingDied(@NonNull ComponentName name) {
- requireNonNull(name);
-
- // Connection permanently lost
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_CONNECTION_LOST,
- new Exception("Host service " + name + " is permanently disconnected"));
- }
-
- @Override
- public void onNullBinding(@NonNull ComponentName name) {
- requireNonNull(name);
-
- // Host rejected the binding.
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_INCOMPATIBLE,
- new Exception("Host service " + name + " rejected the binding "
- + "request"));
- }
- };
-
@SuppressWarnings("deprecation")
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
-
- mServiceDispatcher = new ServiceDispatcher(mErrorHandler);
setContentView(R.layout.activity_template);
mSurfaceView = requireViewById(R.id.template_view_surface);
- mActivityLifecycleDelegate = new ActivityLifecycleDelegate(mServiceDispatcher);
- mSurfaceHolderListener = new SurfaceHolderListener(mServiceDispatcher,
- new SurfaceWrapperProvider(mSurfaceView));
- mServiceComponentName = retrieveServiceComponentName();
- if (mServiceComponentName == null) {
- Log.e(TAG, "Unspecified service class name");
+ ComponentName serviceComponentName = retrieveServiceComponentName();
+ if (serviceComponentName == null) {
+ Log.e(LogTags.TAG, "Unspecified service class name");
finish();
return;
}
+ mDisplayId = getWindowManager().getDefaultDisplay().getDisplayId();
- registerActivityLifecycleCallbacks(mActivityLifecycleDelegate);
+ CarAppViewModelFactory factory = CarAppViewModelFactory.getInstance(getApplication(),
+ serviceComponentName);
+ mViewModel = new ViewModelProvider(this, factory).get(CarAppViewModel.class);
+ mViewModel.getErrorEvent().observe(this,
+ errorEvent -> mErrorHandler.onError(errorEvent.getErrorType(),
+ errorEvent.getException()));
+
+ mActivityLifecycleDelegate = new ActivityLifecycleDelegate(getServiceDispatcher());
+ mSurfaceHolderListener = new SurfaceHolderListener(getServiceDispatcher(),
+ new SurfaceWrapperProvider(mSurfaceView));
+
+ registerActivityLifecycleCallbacks(requireNonNull(mActivityLifecycleDelegate));
// Set the z-order to receive the UI events on the surface.
mSurfaceView.setZOrderOnTop(true);
- mSurfaceView.setServiceDispatcher(mServiceDispatcher);
+ mSurfaceView.setServiceDispatcher(getServiceDispatcher());
mSurfaceView.setErrorHandler(mErrorHandler);
mSurfaceView.getHolder().addCallback(mSurfaceHolderListener);
- mDisplayId = getWindowManager().getDefaultDisplay().getDisplayId();
- bindService();
+
+ mViewModel.bind(getIntent(), mCarActivity, mDisplayId);
}
@Override
@@ -300,13 +247,6 @@
}
}
- @Override
- protected void onDestroy() {
- if (isFinishing()) {
- unbindService();
- }
- super.onDestroy();
- }
@Override
public void onBackPressed() {
@@ -318,21 +258,7 @@
@Override
protected void onNewIntent(@NonNull Intent intent) {
super.onNewIntent(intent);
- if (!mServiceDispatcher.isBound()) {
- bindService();
- } else {
- updateIntent(intent);
- }
- }
-
- @VisibleForTesting
- ServiceConnection getServiceConnection() {
- return mServiceConnectionImpl;
- }
-
- @VisibleForTesting
- void setServiceConnection(ServiceConnection serviceConnection) {
- mServiceConnectionImpl = serviceConnection;
+ requireNonNull(mViewModel).bind(intent, mCarActivity, mDisplayId);
}
@VisibleForTesting
@@ -340,6 +266,11 @@
return mDisplayId;
}
+ @VisibleForTesting
+ ServiceDispatcher getServiceDispatcher() {
+ return requireNonNull(mViewModel).getServiceDispatcher();
+ }
+
@Nullable
private ComponentName retrieveServiceComponentName() {
ActivityInfo activityInfo = null;
@@ -348,7 +279,7 @@
getPackageManager()
.getActivityInfo(getComponentName(), PackageManager.GET_META_DATA);
} catch (NameNotFoundException e) {
- Log.e(TAG, "Unable to find component: " + getComponentName(), e);
+ Log.e(LogTags.TAG, "Unable to find component: " + getComponentName(), e);
}
if (activityInfo == null) {
@@ -358,7 +289,7 @@
String serviceName = activityInfo.metaData.getString(SERVICE_METADATA_KEY);
if (serviceName == null) {
Log.e(
- TAG,
+ LogTags.TAG,
"Unable to find required metadata tag with name "
+ SERVICE_METADATA_KEY
+ ". App manifest must include metadata tag with name "
@@ -369,113 +300,4 @@
return new ComponentName(this, serviceName);
}
-
- /** Binds to the renderer service. */
- private void bindService() {
- Intent rendererIntent = new Intent(ACTION_RENDER);
- List<ResolveInfo> resolveInfoList =
- getPackageManager()
- .queryIntentServices(rendererIntent, PackageManager.GET_META_DATA);
- if (resolveInfoList.size() == 1) {
- rendererIntent.setPackage(resolveInfoList.get(0).serviceInfo.packageName);
- if (!bindService(
- rendererIntent,
- mServiceConnectionImpl,
- Context.BIND_AUTO_CREATE | Context.BIND_INCLUDE_CAPABILITIES)) {
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_INCOMPATIBLE,
- new Exception("Cannot bind to the renderer host with intent: "
- + rendererIntent));
- }
- } else if (resolveInfoList.isEmpty()) {
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_NOT_FOUND, new Exception("No "
- + "handlers found for intent: " + rendererIntent));
- } else {
- StringBuilder logMessage =
- new StringBuilder("Multiple hosts found, only one is allowed");
- for (ResolveInfo resolveInfo : resolveInfoList) {
- logMessage.append(
- String.format("\nFound host %s", resolveInfo.serviceInfo.packageName));
- }
- mErrorHandler.onError(ErrorHandler.ErrorType.MULTIPLE_HOSTS,
- new Exception(logMessage.toString()));
- }
- }
-
- /**
- * Verifies that the renderer service supports the current version.
- *
- * @param rendererService the renderer service which should verify the version
- */
- void verifyServiceVersion(IRendererService rendererService) {
- // TODO(169604451) Add version support logic
- boolean isCompatible = true;
-
- if (!isCompatible) {
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_INCOMPATIBLE,
- new Exception("Renderer service unsupported"));
- }
- }
-
- /**
- * Initializes the {@code rendererService} for the current activity with {@code carActivity},
- * {@code serviceComponentName} and {@code displayId}.
- *
- * @param rendererService the renderer service that needs to be initialized
- */
- void initializeService(@NonNull IRendererService rendererService) {
- requireNonNull(rendererService);
- requireNonNull(mServiceComponentName);
- ComponentName serviceComponentName = mServiceComponentName;
- Boolean success = mServiceDispatcher.fetch(false,
- () -> rendererService.initialize(mCarActivity,
- serviceComponentName, mDisplayId));
- if (success == null || !success) {
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_ERROR,
- new Exception("Cannot create renderer for" + mServiceComponentName));
- }
- }
-
- /** Closes the connection to the connected {@code rendererService} if any. */
- void unbindService() {
- // Remove the renderer callback since there is no need to communicate the state with
- // the host.
- mActivityLifecycleDelegate.registerRendererCallback(null);
- // Stop sending SurfaceView updates
- mSurfaceView.getHolder().removeCallback(mSurfaceHolderListener);
- // If host has already disconnected, there is no need for an unbind.
- IRendererService rendererService = mServiceDispatcher.getRendererService();
- if (rendererService == null) {
- return;
- }
- try {
- rendererService.terminate(requireNonNull(mServiceComponentName));
- } catch (RemoteException e) {
- // We are already unbinding (maybe because the host has already cut the connection)
- // Let's not log more errors unnecessarily.
- }
-
- Log.i(LogTags.TAG, "Unbinding from " + mServiceComponentName);
- unbindService(mServiceConnectionImpl);
- mServiceDispatcher.setRendererService(null);
- }
-
- /**
- * Updates the activity intent for the {@code rendererService}.
- */
- void updateIntent(Intent intent) {
- requireNonNull(mServiceComponentName);
- IRendererService service = mServiceDispatcher.getRendererService();
- if (service == null) {
- mErrorHandler.onError(ErrorHandler.ErrorType.CLIENT_SIDE_ERROR,
- new Exception("Service dispatcher is not connected"));
- return;
- }
- ComponentName serviceComponentName = mServiceComponentName;
- Boolean success = mServiceDispatcher.fetch(false, () ->
- service.onNewIntent(intent, serviceComponentName, mDisplayId));
- if (success == null || !success) {
- mErrorHandler.onError(ErrorHandler.ErrorType.HOST_ERROR, new Exception("Renderer "
- + "cannot handle the intent: " + intent));
- }
- }
}
diff --git a/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppViewModel.java b/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppViewModel.java
new file mode 100644
index 0000000..aa48ca9
--- /dev/null
+++ b/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppViewModel.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.car.app.activity;
+
+import static androidx.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.app.Application;
+import android.content.ComponentName;
+import android.content.Intent;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.car.app.activity.renderer.ICarAppActivity;
+import androidx.car.app.activity.renderer.IRendererCallback;
+import androidx.lifecycle.AndroidViewModel;
+import androidx.lifecycle.MutableLiveData;
+
+/**
+ * The view model to keep track of the CarAppActivity data.
+ *
+ * This main role of this class is to extent the life of a service connection beyond the regular
+ * lifecycle of an activity. This is done by making sure the unbind happens when the view model
+ * clears instead of when the activity calls onDestroy.
+ *
+ * @hide
+ */
+@RestrictTo(LIBRARY)
+public class CarAppViewModel extends AndroidViewModel implements ErrorHandler {
+ /** Holds the information about an error event. */
+ public static class ErrorEvent {
+ private final ErrorType mErrorType;
+ private final Throwable mException;
+
+ public ErrorEvent(@NonNull ErrorType errorType, @NonNull Throwable exception) {
+ mErrorType = errorType;
+ mException = exception;
+ }
+
+ /** Returns the type of error. */
+ @NonNull ErrorType getErrorType() {
+ return mErrorType;
+ }
+
+ /** Returns the exception associated with this error event. */
+ @NonNull Throwable getException() {
+ return mException;
+ }
+ }
+
+ private final MutableLiveData<ErrorEvent> mErrorEvent = new MutableLiveData<>();
+ private ServiceConnectionManager mServiceConnectionManager;
+ @Nullable private IRendererCallback mIRendererCallback;
+
+ public CarAppViewModel(@NonNull Application application, @NonNull ComponentName componentName) {
+ super(application);
+
+ mServiceConnectionManager = new ServiceConnectionManager(application, componentName, this);
+ }
+
+ @VisibleForTesting
+ @NonNull ServiceConnectionManager getServiceConnectionManager() {
+ return mServiceConnectionManager;
+ }
+
+ @VisibleForTesting
+ void setServiceConnectionManager(ServiceConnectionManager serviceConnectionManager) {
+ mServiceConnectionManager = serviceConnectionManager;
+ }
+
+ @NonNull ServiceDispatcher getServiceDispatcher() {
+ return mServiceConnectionManager.getServiceDispatcher();
+ }
+
+ /** Updates the rendeer callback. */
+ void setRendererCallback(@NonNull IRendererCallback rendererCallback) {
+ mIRendererCallback = rendererCallback;
+ }
+
+ /**
+ * Binds to the renderer service and initializes the service if not bound already.
+ *
+ * Initializes the renderer service with given properties if already bound to the renderer
+ * service.
+ */
+ void bind(@NonNull Intent intent, @NonNull ICarAppActivity iCarAppActivity,
+ int displayId) {
+ mServiceConnectionManager.bind(intent, iCarAppActivity, displayId);
+ }
+
+ /** Closes the connection to the renderer service if any. */
+ void unbind() {
+ mServiceConnectionManager.unbind();
+ }
+
+ @NonNull
+ MutableLiveData<ErrorEvent> getErrorEvent() {
+ return mErrorEvent;
+ }
+
+ @Override
+ protected void onCleared() {
+ super.onCleared();
+ if (mIRendererCallback != null) {
+ mServiceConnectionManager.getServiceDispatcher()
+ .dispatch(mIRendererCallback::onDestroyed);
+ }
+ mServiceConnectionManager.unbind();
+ }
+
+ @Override
+ public void onError(@NonNull ErrorHandler.ErrorType errorType, @NonNull Throwable exception) {
+ mErrorEvent.setValue(new ErrorEvent(errorType, exception));
+ }
+}
diff --git a/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppViewModelFactory.java b/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppViewModelFactory.java
new file mode 100644
index 0000000..3c9627d
--- /dev/null
+++ b/car/app/app-activity/src/main/java/androidx/car/app/activity/CarAppViewModelFactory.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.car.app.activity;
+
+import static androidx.annotation.RestrictTo.Scope.LIBRARY;
+
+import android.app.Application;
+import android.content.ComponentName;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RestrictTo;
+import androidx.lifecycle.ViewModel;
+import androidx.lifecycle.ViewModelProvider;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A factory to provide a unique {@link CarAppViewModel} for each given {@link ComponentName}.
+ *
+ * @hide
+ */
+@RestrictTo(LIBRARY)
+class CarAppViewModelFactory implements ViewModelProvider.Factory {
+ private static final Map<ComponentName, CarAppViewModelFactory> sInstances = new HashMap<>();
+
+ Application mApplication;
+ ComponentName mComponentName;
+
+ private CarAppViewModelFactory(@NonNull ComponentName componentName,
+ @NonNull Application application) {
+ mComponentName = componentName;
+ mApplication = application;
+ }
+
+ /**
+ * Retrieve a singleton instance of CarAppViewModelFactory for the given key.
+ *
+ * @return A valid {@link CarAppViewModelFactory}
+ */
+ @NonNull
+ static CarAppViewModelFactory getInstance(Application application,
+ ComponentName componentName) {
+ CarAppViewModelFactory instance = sInstances.get(componentName);
+ if (instance == null) {
+ instance = new CarAppViewModelFactory(componentName, application);
+ sInstances.put(componentName, instance);
+ }
+ return instance;
+ }
+
+ @SuppressWarnings("unchecked")
+ @NonNull
+ @Override
+ public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
+ return (T) new CarAppViewModel(mApplication, mComponentName);
+ }
+}
diff --git a/car/app/app-activity/src/main/java/androidx/car/app/activity/ServiceConnectionManager.java b/car/app/app-activity/src/main/java/androidx/car/app/activity/ServiceConnectionManager.java
new file mode 100644
index 0000000..93f9b5d
--- /dev/null
+++ b/car/app/app-activity/src/main/java/androidx/car/app/activity/ServiceConnectionManager.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.car.app.activity;
+
+import static androidx.annotation.RestrictTo.Scope.LIBRARY;
+
+import static java.util.Objects.requireNonNull;
+
+import android.annotation.SuppressLint;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
+import androidx.car.app.activity.renderer.ICarAppActivity;
+import androidx.car.app.activity.renderer.IRendererService;
+
+import java.util.List;
+
+/**
+ * Manages the renderer service connection state.
+ *
+ * This class handles binding and unbinding to the renderer service and make sure the renderer
+ * service gets initialized and terminated properly.
+ *
+ * @hide
+ */
+@RestrictTo(LIBRARY)
+public class ServiceConnectionManager {
+ @SuppressLint({"ActionValue"})
+ @VisibleForTesting
+ static final String ACTION_RENDER = "android.car.template.host.RendererService";
+
+ final ErrorHandler mErrorHandler;
+ private final ComponentName mServiceComponentName;
+ private final Context mContext;
+ private final ServiceDispatcher mServiceDispatcher;
+ private int mDisplayId;
+ @Nullable private Intent mIntent;
+ @Nullable private ICarAppActivity mICarAppActivity;
+
+ @Nullable IRendererService mRendererService;
+
+ public ServiceConnectionManager(@NonNull Context context,
+ @NonNull ComponentName serviceComponentName, @NonNull ErrorHandler errorHandler) {
+ mContext = context;
+ mErrorHandler = errorHandler;
+ mServiceComponentName = serviceComponentName;
+ mServiceDispatcher = new ServiceDispatcher(mErrorHandler, this::isBound);
+ }
+
+ /**
+ * Returns a {@link ServiceDispatcher} that can be used to communicate with the renderer
+ * service.
+ */
+ @NonNull ServiceDispatcher getServiceDispatcher() {
+ return mServiceDispatcher;
+ }
+
+ @VisibleForTesting
+ ComponentName getServiceComponentName() {
+ return mServiceComponentName;
+ }
+
+ @VisibleForTesting
+ ErrorHandler getErrorHandler() {
+ return mErrorHandler;
+ }
+
+ @VisibleForTesting
+ ServiceConnection getServiceConnection() {
+ return mServiceConnectionImpl;
+ }
+
+ @VisibleForTesting
+ void setServiceConnection(ServiceConnection serviceConnection) {
+ mServiceConnectionImpl = serviceConnection;
+ }
+
+ @VisibleForTesting
+ void setRendererService(@Nullable IRendererService rendererService) {
+ mRendererService = rendererService;
+ }
+
+ /** Returns true if the service is currently bound and able to receive messages */
+ boolean isBound() {
+ return mRendererService != null;
+ }
+
+ /** The service connection for the renderer service. */
+ private ServiceConnection mServiceConnectionImpl =
+ new ServiceConnection() {
+ @Override
+ public void onServiceConnected(
+ @NonNull ComponentName name, @NonNull IBinder service) {
+ requireNonNull(name);
+ requireNonNull(service);
+ Log.i(LogTags.TAG, String.format("Host service %s is connected",
+ name.flattenToShortString()));
+ IRendererService rendererService = IRendererService.Stub.asInterface(service);
+ if (rendererService == null) {
+ mErrorHandler.onError(ErrorHandler.ErrorType.HOST_INCOMPATIBLE,
+ new Exception("Failed to get IRenderService binder from host: "
+ + name));
+ return;
+ }
+
+ mRendererService = rendererService;
+ initializeService();
+ }
+
+ @Override
+ public void onServiceDisconnected(@NonNull ComponentName name) {
+ requireNonNull(name);
+
+ // Connection lost, but it might reconnect.
+ Log.w(LogTags.TAG, String.format("Host service %s is disconnected",
+ name.flattenToShortString()));
+ }
+
+ @Override
+ public void onBindingDied(@NonNull ComponentName name) {
+ requireNonNull(name);
+
+ // Connection permanently lost
+ mErrorHandler.onError(ErrorHandler.ErrorType.HOST_CONNECTION_LOST,
+ new Exception("Host service " + name + " is permanently disconnected"));
+ }
+
+ @Override
+ public void onNullBinding(@NonNull ComponentName name) {
+ requireNonNull(name);
+
+ // Host rejected the binding.
+ mErrorHandler.onError(ErrorHandler.ErrorType.HOST_INCOMPATIBLE,
+ new Exception("Host service " + name + " rejected the binding "
+ + "request"));
+ }
+ };
+
+ /**
+ * Binds to the renderer service and initializes the service if not bound already.
+ *
+ * Initializes the renderer service with given properties if already bound to the renderer
+ * service.
+ */
+ void bind(@NonNull Intent intent, @NonNull ICarAppActivity iCarAppActivity, int displayId) {
+ mIntent = requireNonNull(intent);
+ mICarAppActivity = requireNonNull(iCarAppActivity);
+ mDisplayId = displayId;
+
+ if (isBound()) {
+ initializeService();
+ return;
+ }
+
+ Intent rendererIntent = new Intent(ACTION_RENDER);
+ List<ResolveInfo> resolveInfoList =
+ mContext.getPackageManager()
+ .queryIntentServices(rendererIntent, PackageManager.GET_META_DATA);
+ if (resolveInfoList.size() == 1) {
+ rendererIntent.setPackage(resolveInfoList.get(0).serviceInfo.packageName);
+ if (!mContext.bindService(
+ rendererIntent,
+ mServiceConnectionImpl,
+ Context.BIND_AUTO_CREATE | Context.BIND_INCLUDE_CAPABILITIES)) {
+ mErrorHandler.onError(ErrorHandler.ErrorType.HOST_INCOMPATIBLE,
+ new Exception("Cannot bind to the renderer host with intent: "
+ + rendererIntent));
+ }
+ } else if (resolveInfoList.isEmpty()) {
+ mErrorHandler.onError(ErrorHandler.ErrorType.HOST_NOT_FOUND, new Exception("No "
+ + "handlers found for intent: " + rendererIntent));
+ } else {
+ StringBuilder logMessage =
+ new StringBuilder("Multiple hosts found, only one is allowed");
+ for (ResolveInfo resolveInfo : resolveInfoList) {
+ logMessage.append(
+ String.format("\nFound host %s", resolveInfo.serviceInfo.packageName));
+ }
+ mErrorHandler.onError(ErrorHandler.ErrorType.MULTIPLE_HOSTS,
+ new Exception(logMessage.toString()));
+ }
+ }
+
+ /** Closes the connection to the connected {@code rendererService} if any. */
+ void unbind() {
+ if (mRendererService == null) {
+ return;
+ }
+ try {
+ mRendererService.terminate(requireNonNull(mServiceComponentName));
+ } catch (RemoteException e) {
+ // We are already unbinding (maybe because the host has already cut the connection)
+ // Let's not log more errors unnecessarily.
+ }
+
+ Log.i(LogTags.TAG, "Unbinding from " + mServiceComponentName);
+ mContext.unbindService(mServiceConnectionImpl);
+ mRendererService = null;
+ }
+
+ /**
+ * Initializes the {@code rendererService} for the current {@code carIAppActivity},
+ * {@code serviceComponentName} and {@code displayId}.
+ */
+ void initializeService() {
+ ICarAppActivity carAppActivity = requireNonNull(mICarAppActivity);
+ IRendererService rendererService = requireNonNull(mRendererService);
+ ComponentName serviceComponentName = requireNonNull(mServiceComponentName);
+
+ Boolean success = mServiceDispatcher.fetch(false,
+ () -> rendererService.initialize(carAppActivity,
+ serviceComponentName, mDisplayId));
+ if (success == null || !success) {
+ mErrorHandler.onError(ErrorHandler.ErrorType.HOST_ERROR,
+ new Exception("Cannot create renderer for" + serviceComponentName));
+ return;
+ }
+ updateIntent();
+ }
+
+ /**
+ * Updates the activity intent for the connected {@code rendererService}.
+ */
+ private void updateIntent() {
+ ComponentName serviceComponentName = requireNonNull(mServiceComponentName);
+ Intent intent = requireNonNull(mIntent);
+
+ IRendererService service = mRendererService;
+ if (service == null) {
+ mErrorHandler.onError(ErrorHandler.ErrorType.CLIENT_SIDE_ERROR,
+ new Exception("Service dispatcher is not connected"));
+ return;
+ }
+
+ Boolean success = mServiceDispatcher.fetch(false, () ->
+ service.onNewIntent(intent, serviceComponentName, mDisplayId));
+ if (success == null || !success) {
+ mErrorHandler.onError(ErrorHandler.ErrorType.HOST_ERROR, new Exception("Renderer "
+ + "cannot handle the intent: " + intent));
+ }
+ }
+}
diff --git a/car/app/app-activity/src/main/java/androidx/car/app/activity/ServiceDispatcher.java b/car/app/app-activity/src/main/java/androidx/car/app/activity/ServiceDispatcher.java
index a77a3e5..83c575f 100644
--- a/car/app/app-activity/src/main/java/androidx/car/app/activity/ServiceDispatcher.java
+++ b/car/app/app-activity/src/main/java/androidx/car/app/activity/ServiceDispatcher.java
@@ -23,6 +23,7 @@
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RestrictTo;
+import androidx.annotation.VisibleForTesting;
import androidx.car.app.activity.renderer.IRendererService;
import androidx.car.app.serialization.BundlerException;
@@ -33,9 +34,15 @@
*/
@RestrictTo(LIBRARY)
public class ServiceDispatcher {
+
+ /** An interface for monitoring the binding state of a service connection. */
+ public interface OnBindingListener {
+ /** Returns true if the service connection is bound. */
+ boolean isBound();
+ }
+
private final ErrorHandler mErrorHandler;
- @Nullable
- private IRendererService mRendererService;
+ private OnBindingListener mOnBindingListener;
/** A one way call to the service */
public interface OneWayCall {
@@ -56,28 +63,15 @@
T invoke() throws RemoteException, BundlerException;
}
- public ServiceDispatcher(@NonNull ErrorHandler errorHandler) {
+ public ServiceDispatcher(@NonNull ErrorHandler errorHandler,
+ @NonNull OnBindingListener onBindingListener) {
mErrorHandler = errorHandler;
+ mOnBindingListener = onBindingListener;
}
- /**
- * Updates the bound service reference
- *
- * @param rendererService bound service or {@code null} if the service is not bound.
- */
- public void setRendererService(@Nullable IRendererService rendererService) {
- mRendererService = rendererService;
- }
-
- /** Returns the bound service, or null if the service is not bound */
- @Nullable
- public IRendererService getRendererService() {
- return mRendererService;
- }
-
- /** Returns true if the service is currently bound and able to receive messages */
- public boolean isBound() {
- return mRendererService != null;
+ @VisibleForTesting
+ public void setOnBindingListener(@NonNull OnBindingListener onBindingListener) {
+ mOnBindingListener = onBindingListener;
}
/** Dispatches the given {@link OneWayCall}. This is a non-blocking call. */
@@ -99,7 +93,7 @@
// TODO(b/184697399): Remove two-way calls as these are blocking.
@Nullable
public <T> T fetch(@Nullable T fallbackValue, @NonNull ReturnCall<T> call) {
- if (mRendererService == null) {
+ if (!mOnBindingListener.isBound()) {
// Avoid dispatching messages if we are not bound to the service
return fallbackValue;
}
diff --git a/car/app/app-activity/src/main/res/layout/activity_template.xml b/car/app/app-activity/src/main/res/layout/activity_template.xml
index 09c432f..7054403 100644
--- a/car/app/app-activity/src/main/res/layout/activity_template.xml
+++ b/car/app/app-activity/src/main/res/layout/activity_template.xml
@@ -1,6 +1,5 @@
<?xml version="1.0" encoding="utf-8"?>
<merge xmlns:android="http://schemas.android.com/apk/res/android"
- xmlns:app="http://schemas.android.com/apk/res-auto"
android:id="@+id/fragment_container">
<androidx.car.app.activity.renderer.surface.TemplateSurfaceView
@@ -11,6 +10,7 @@
android:focusableInTouchMode="true" />
<LinearLayout
+ android:background="#000000"
android:id="@+id/error_message_container"
android:layout_width="match_parent"
android:layout_height="match_parent"
diff --git a/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppActivityTest.java b/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppActivityTest.java
index 8cb2e32..7ffef3b 100644
--- a/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppActivityTest.java
+++ b/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppActivityTest.java
@@ -239,8 +239,11 @@
CarAppActivity.class)) {
scenario.onActivity(activity -> {
try {
- ServiceConnection serviceConnection = spy(activity.getServiceConnection());
- activity.setServiceConnection(serviceConnection);
+ ServiceConnectionManager serviceConnectionManager =
+ activity.mViewModel.getServiceConnectionManager();
+ ServiceConnection serviceConnection =
+ spy(serviceConnectionManager.getServiceConnection());
+ serviceConnectionManager.setServiceConnection(serviceConnection);
// Destroy activity to force unbind.
scenario.moveToState(Lifecycle.State.DESTROYED);
@@ -251,7 +254,7 @@
// Verify service connection is closed.
verify(serviceConnection, times(1)).onServiceDisconnected(
mRendererComponent);
- assertThat(activity.mServiceDispatcher.isBound()).isFalse();
+ assertThat(serviceConnectionManager.isBound()).isFalse();
} catch (RemoteException e) {
fail(Log.getStackTraceString(e));
}
diff --git a/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppViewModelFactoryTest.java b/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppViewModelFactoryTest.java
new file mode 100644
index 0000000..7650a2d
--- /dev/null
+++ b/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppViewModelFactoryTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.car.app.activity;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.app.Application;
+import android.content.ComponentName;
+
+import androidx.test.core.app.ApplicationProvider;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.internal.DoNotInstrument;
+
+/** Tests for {@link CarAppViewModelFactory} */
+@RunWith(RobolectricTestRunner.class)
+@DoNotInstrument
+public class CarAppViewModelFactoryTest {
+ private static final ComponentName TEST_COMPONENT_NAME_1 = new ComponentName(
+ ApplicationProvider.getApplicationContext(), "Class1");
+ private static final ComponentName TEST_COMPONENT_NAME_2 = new ComponentName(
+ ApplicationProvider.getApplicationContext(), "Class2");
+
+ private final Application mApplication = ApplicationProvider.getApplicationContext();
+
+ @Test
+ public void getInstance_sameKey_returnsSame() {
+ CarAppViewModelFactory factory1 = CarAppViewModelFactory.getInstance(mApplication,
+ TEST_COMPONENT_NAME_1);
+
+ CarAppViewModelFactory factory2 = CarAppViewModelFactory.getInstance(mApplication,
+ TEST_COMPONENT_NAME_1);
+
+ assertThat(factory1).isEqualTo(factory2);
+ }
+
+ @Test
+ public void getInstance_differentKeys_returnsDifferent() {
+ CarAppViewModelFactory factory1 = CarAppViewModelFactory.getInstance(mApplication,
+ TEST_COMPONENT_NAME_1);
+
+ CarAppViewModelFactory factory2 = CarAppViewModelFactory.getInstance(mApplication,
+ TEST_COMPONENT_NAME_2);
+
+ assertThat(factory1).isNotEqualTo(factory2);
+ }
+
+ @Test
+ public void create_correctComponentName() {
+ CarAppViewModelFactory factory = CarAppViewModelFactory.getInstance(mApplication,
+ TEST_COMPONENT_NAME_1);
+
+ CarAppViewModel viewModel = factory.create(CarAppViewModel.class);
+
+ assertThat(viewModel).isNotNull();
+ assertThat(viewModel.getServiceConnectionManager().getServiceComponentName())
+ .isEqualTo(TEST_COMPONENT_NAME_1);
+ }
+}
diff --git a/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppViewModelTest.java b/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppViewModelTest.java
new file mode 100644
index 0000000..9eda009
--- /dev/null
+++ b/car/app/app-activity/src/test/java/androidx/car/app/activity/CarAppViewModelTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.car.app.activity;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.app.Application;
+import android.content.ComponentName;
+import android.content.Intent;
+
+import androidx.car.app.activity.renderer.ICarAppActivity;
+import androidx.test.core.app.ApplicationProvider;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.internal.DoNotInstrument;
+
+/** Tests for {@link CarAppViewModel} */
+@RunWith(RobolectricTestRunner.class)
+@DoNotInstrument
+public class CarAppViewModelTest {
+ private static final ComponentName TEST_COMPONENT_NAME = new ComponentName(
+ ApplicationProvider.getApplicationContext(), "Class1");
+ private static final int TEST_DISPLAY_ID = 123;
+ private static final Intent TEST_INTENT = new Intent("TestAction");
+
+ private final Application mApplication = ApplicationProvider.getApplicationContext();
+ private CarAppViewModel mCarAppViewModel;
+ private ICarAppActivity mICarAppActivity;
+
+ @Before
+ public void setUp() {
+ mCarAppViewModel = new CarAppViewModel(mApplication, TEST_COMPONENT_NAME);
+ mICarAppActivity = mock(ICarAppActivity.class);
+ }
+
+ @Test
+ public void testSetup() {
+ assertThat(mCarAppViewModel.getServiceConnectionManager()).isNotNull();
+ assertThat(mCarAppViewModel.getServiceConnectionManager().getServiceComponentName())
+ .isEqualTo(TEST_COMPONENT_NAME);
+ assertThat(mCarAppViewModel.getServiceDispatcher()).isNotNull();
+ }
+
+ @Test
+ public void testBind_serviceConnectionManager_invoke() {
+ ServiceConnectionManager serviceConnectionManager = mock(ServiceConnectionManager.class);
+ mCarAppViewModel.setServiceConnectionManager(serviceConnectionManager);
+ mCarAppViewModel.bind(TEST_INTENT, mICarAppActivity, TEST_DISPLAY_ID);
+
+ verify(serviceConnectionManager).bind(TEST_INTENT, mICarAppActivity, TEST_DISPLAY_ID);
+ }
+
+ @Test
+ public void testUnbind_serviceConnectionManager_invoke() {
+ ServiceConnectionManager serviceConnectionManager = mock(ServiceConnectionManager.class);
+ mCarAppViewModel.setServiceConnectionManager(serviceConnectionManager);
+ mCarAppViewModel.unbind();
+
+ verify(serviceConnectionManager).unbind();
+ }
+
+ @Test
+ public void testErrorHandler_capturesErrorEvent() {
+ ErrorHandler.ErrorType errorType = ErrorHandler.ErrorType.HOST_ERROR;
+ Throwable exception = new IllegalStateException();
+
+ ErrorHandler errorHandler =
+ mCarAppViewModel.getServiceConnectionManager().getErrorHandler();
+ errorHandler.onError(errorType, exception);
+
+ CarAppViewModel.ErrorEvent errorEvent = mCarAppViewModel.getErrorEvent().getValue();
+ assertThat(errorEvent).isNotNull();
+ assertThat(errorEvent.getErrorType()).isEqualTo(errorType);
+ assertThat(errorEvent.getException()).isEqualTo(exception);
+ }
+}
diff --git a/car/app/app-activity/src/test/java/androidx/car/app/activity/ServiceConnectionManagerTest.java b/car/app/app-activity/src/test/java/androidx/car/app/activity/ServiceConnectionManagerTest.java
new file mode 100644
index 0000000..82bc8c1
--- /dev/null
+++ b/car/app/app-activity/src/test/java/androidx/car/app/activity/ServiceConnectionManagerTest.java
@@ -0,0 +1,289 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.car.app.activity;
+
+import static android.os.Looper.getMainLooper;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.Application;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.os.RemoteException;
+import android.util.Log;
+
+import androidx.car.app.activity.renderer.ICarAppActivity;
+import androidx.car.app.activity.renderer.IRendererService;
+import androidx.test.core.app.ApplicationProvider;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.internal.DoNotInstrument;
+import org.robolectric.shadows.ShadowApplication;
+import org.robolectric.shadows.ShadowPackageManager;
+
+/** Tests for {@link ServiceConnectionManager}. */
+@RunWith(RobolectricTestRunner.class)
+@DoNotInstrument
+public class ServiceConnectionManagerTest {
+
+ private static final int TEST_DISPLAY_ID = 123;
+ private static final Intent TEST_INTENT = new Intent("Test");
+
+ private final ComponentName mRendererComponent = new ComponentName(
+ ApplicationProvider.getApplicationContext(), getClass().getName());
+
+ private final String mFakeCarAppServiceClass = "com.fake.FakeCarAppService";
+ private final ComponentName mFakeCarAppServiceComponent = new ComponentName(
+ ApplicationProvider.getApplicationContext(), mFakeCarAppServiceClass);
+ private final IRendererService mRenderService = mock(IRendererService.class);
+ private final RenderServiceDelegate mRenderServiceDelegate =
+ new RenderServiceDelegate(mRenderService);
+
+ private final ErrorHandler mErrorHandler = mock(ErrorHandler.class);
+ private final ServiceConnectionManager mServiceConnectionManager =
+ new ServiceConnectionManager(ApplicationProvider.getApplicationContext(),
+ mFakeCarAppServiceComponent, mErrorHandler);
+
+ private void setupCarAppActivityForTesting() {
+ try {
+ Application app = ApplicationProvider.getApplicationContext();
+
+ PackageManager packageManager = app.getPackageManager();
+ ShadowPackageManager spm = shadowOf(packageManager);
+
+ // Register fake renderer service which will be simulated by {@code mRenderService}.
+ spm.addServiceIfNotPresent(mRendererComponent);
+ spm.addIntentFilterForService(mRendererComponent,
+ new IntentFilter(CarAppActivity.ACTION_RENDER));
+
+ when(mRenderService.initialize(any(ICarAppActivity.class),
+ any(ComponentName.class),
+ anyInt())).thenReturn(true);
+ when(mRenderService.onNewIntent(any(Intent.class), any(ComponentName.class),
+ anyInt())).thenReturn(true);
+
+ ShadowApplication sa = shadowOf(app);
+ sa.setComponentNameAndServiceForBindService(mRendererComponent, mRenderServiceDelegate);
+ } catch (Exception e) {
+ fail(Log.getStackTraceString(e));
+ }
+ }
+
+ @Test
+ public void testIsBound_serviceNotNull_returnsTrue() {
+ mServiceConnectionManager.setRendererService(mock(IRendererService.class));
+ assertThat(mServiceConnectionManager.isBound()).isTrue();
+ }
+
+ @Test
+ public void testIsBound_serviceIsNull_returnsFalse() {
+ mServiceConnectionManager.setRendererService(null);
+ assertThat(mServiceConnectionManager.isBound()).isFalse();
+ }
+
+ @Test
+ public void testBind_unbound_bindsToRenderer() {
+ setupCarAppActivityForTesting();
+ ICarAppActivity iCarAppActivity = mock(ICarAppActivity.class);
+
+ mServiceConnectionManager.bind(TEST_INTENT, iCarAppActivity, TEST_DISPLAY_ID);
+ shadowOf(getMainLooper()).idle();
+ try {
+ verify(mErrorHandler, never()).onError(any(), any());
+ verify(mRenderService).initialize(iCarAppActivity, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ verify(mRenderService).onNewIntent(TEST_INTENT, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+ assertThat(mServiceConnectionManager.isBound()).isTrue();
+ }
+
+ @Test
+ public void testBind_bound_doesNotRebound() {
+ setupCarAppActivityForTesting();
+ ICarAppActivity iCarAppActivity = mock(ICarAppActivity.class);
+
+ IRendererService renderService = createMockRendererService();
+ mServiceConnectionManager.setRendererService(renderService);
+ mServiceConnectionManager.bind(TEST_INTENT, iCarAppActivity, TEST_DISPLAY_ID);
+ shadowOf(getMainLooper()).idle();
+ try {
+ verify(mErrorHandler, never()).onError(any(), any());
+ verify(mRenderService, never()).initialize(iCarAppActivity, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ verify(mRenderService, never()).onNewIntent(TEST_INTENT, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+ assertThat(mServiceConnectionManager.isBound()).isTrue();
+ }
+
+ @Test
+ public void testBind_bound_initializes() {
+ setupCarAppActivityForTesting();
+ ICarAppActivity iCarAppActivity = mock(ICarAppActivity.class);
+
+ IRendererService renderService = createMockRendererService();
+
+ mServiceConnectionManager.setRendererService(renderService);
+ mServiceConnectionManager.bind(TEST_INTENT, iCarAppActivity, TEST_DISPLAY_ID);
+ shadowOf(getMainLooper()).idle();
+
+ try {
+ verify(mErrorHandler, never()).onError(any(), any());
+ verify(renderService).initialize(iCarAppActivity, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ verify(renderService).onNewIntent(TEST_INTENT, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+ assertThat(mServiceConnectionManager.isBound()).isTrue();
+ }
+
+ @Test
+ public void testBind_bound_noRebound() {
+ setupCarAppActivityForTesting();
+ ICarAppActivity iCarAppActivity = mock(ICarAppActivity.class);
+ IRendererService renderService = createMockRendererService();
+
+ mServiceConnectionManager.setRendererService(renderService);
+ mServiceConnectionManager.bind(TEST_INTENT, iCarAppActivity, TEST_DISPLAY_ID);
+ shadowOf(getMainLooper()).idle();
+ try {
+ verify(mErrorHandler, never()).onError(any(), any());
+ verify(mRenderService, never()).initialize(iCarAppActivity, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ verify(mRenderService, never()).onNewIntent(TEST_INTENT, mFakeCarAppServiceComponent,
+ TEST_DISPLAY_ID);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+ assertThat(mServiceConnectionManager.isBound()).isTrue();
+ }
+
+ @Test
+ public void testBind_unbound_failure() {
+ setupCarAppActivityForTesting();
+ ICarAppActivity iCarAppActivity = mock(ICarAppActivity.class);
+
+ try {
+ when(mRenderService.initialize(any(ICarAppActivity.class),
+ any(ComponentName.class),
+ anyInt())).thenReturn(false);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+
+ mServiceConnectionManager.bind(TEST_INTENT, iCarAppActivity, TEST_DISPLAY_ID);
+ shadowOf(getMainLooper()).idle();
+
+ verify(mErrorHandler).onError(eq(ErrorHandler.ErrorType.HOST_ERROR), any());
+ }
+
+ @Test
+ public void testUnBind_bound_terminate() {
+ setupCarAppActivityForTesting();
+
+ IRendererService renderService = mock(IRendererService.class);
+ mServiceConnectionManager.setRendererService(renderService);
+ mServiceConnectionManager.unbind();
+ shadowOf(getMainLooper()).idle();
+
+ try {
+ verify(renderService).terminate(mFakeCarAppServiceComponent);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+
+ assertThat(mServiceConnectionManager.isBound()).isFalse();
+ }
+
+ @Test
+ public void testUnBind_unbound_doNothing() {
+ setupCarAppActivityForTesting();
+
+ mServiceConnectionManager.unbind();
+ shadowOf(getMainLooper()).idle();
+
+ try {
+ verify(mRenderService, never()).terminate(mFakeCarAppServiceComponent);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+
+ assertThat(mServiceConnectionManager.isBound()).isFalse();
+ }
+
+ // Use delegate to forward events to a mock. Mockito interceptor is not maintained on
+ // top-level IBinder after call to IRenderService.Stub.asInterface() in CarAppActivity.
+ private static class RenderServiceDelegate extends IRendererService.Stub {
+ private final IRendererService mService;
+
+ RenderServiceDelegate(IRendererService service) {
+ mService = service;
+ }
+
+ @Override
+ public boolean initialize(ICarAppActivity carActivity, ComponentName serviceName,
+ int displayId) throws RemoteException {
+ return mService.initialize(carActivity, serviceName, displayId);
+ }
+
+ @Override
+ public boolean onNewIntent(Intent intent, ComponentName serviceName, int displayId)
+ throws RemoteException {
+ return mService.onNewIntent(intent, serviceName, displayId);
+ }
+
+ @Override
+ public void terminate(ComponentName serviceName) throws RemoteException {
+ mService.terminate(serviceName);
+ }
+ }
+
+ private IRendererService createMockRendererService() {
+ IRendererService renderService = mock(IRendererService.class);
+ try {
+ when(renderService.initialize(any(ICarAppActivity.class),
+ any(ComponentName.class),
+ anyInt())).thenReturn(true);
+ when(renderService.onNewIntent(any(Intent.class), any(ComponentName.class),
+ anyInt())).thenReturn(true);
+ } catch (RemoteException e) {
+ fail(Log.getStackTraceString(e));
+ }
+ return renderService;
+ }
+}
diff --git a/car/app/app-activity/src/test/java/androidx/car/app/activity/ServiceDispatcherTest.java b/car/app/app-activity/src/test/java/androidx/car/app/activity/ServiceDispatcherTest.java
index bbb8137..ea22617 100644
--- a/car/app/app-activity/src/test/java/androidx/car/app/activity/ServiceDispatcherTest.java
+++ b/car/app/app-activity/src/test/java/androidx/car/app/activity/ServiceDispatcherTest.java
@@ -48,19 +48,7 @@
@Before
public void setup() {
mErrorHandler = mock(ErrorHandler.class);
- mServiceDispatcher = new ServiceDispatcher(mErrorHandler);
- }
-
- @Test
- public void isBound_serviceNotNull_returnsTrue() {
- mServiceDispatcher.setRendererService(mock(IRendererService.class));
- assertThat(mServiceDispatcher.isBound()).isTrue();
- }
-
- @Test
- public void isBound_serviceIsNull_returnsFalse() {
- mServiceDispatcher.setRendererService(null);
- assertThat(mServiceDispatcher.isBound()).isFalse();
+ mServiceDispatcher = new ServiceDispatcher(mErrorHandler, () -> false);
}
@Test
@@ -73,7 +61,7 @@
ServiceDispatcher.OneWayCall call = () -> rendererService.onNewIntent(intent,
componentName, 0);
- mServiceDispatcher.setRendererService(rendererService);
+ mServiceDispatcher.setOnBindingListener(() -> true);
mServiceDispatcher.dispatch(call);
verify(rendererService, times(1)).onNewIntent(intent, componentName, 0);
@@ -83,7 +71,7 @@
public void dispatch_serviceNotBound_notInvoked() throws BundlerException, RemoteException {
ServiceDispatcher.OneWayCall call = mock(ServiceDispatcher.OneWayCall.class);
- mServiceDispatcher.setRendererService(null);
+ mServiceDispatcher.setOnBindingListener(() -> false);
mServiceDispatcher.dispatch(call);
verify(call, never()).invoke();
@@ -95,7 +83,7 @@
throw new RemoteException();
};
- mServiceDispatcher.setRendererService(mock(IRendererService.class));
+ mServiceDispatcher.setOnBindingListener(() -> true);
mServiceDispatcher.dispatch(call);
verify(mErrorHandler, times(1))
@@ -104,10 +92,9 @@
@Test
public void fetch_serviceBound_valueReturned() {
- IRendererService rendererService = mock(IRendererService.class);
ServiceDispatcher.ReturnCall<Integer> call = () -> 123;
- mServiceDispatcher.setRendererService(rendererService);
+ mServiceDispatcher.setOnBindingListener(() -> true);
Integer result = mServiceDispatcher.fetch(234, call);
assertThat(result).isEqualTo(123);
@@ -119,7 +106,7 @@
throws BundlerException, RemoteException {
ServiceDispatcher.ReturnCall<Integer> call = mock(ServiceDispatcher.ReturnCall.class);
- mServiceDispatcher.setRendererService(null);
+ mServiceDispatcher.setOnBindingListener(() -> false);
Integer result = mServiceDispatcher.fetch(234, call);
verify(call, never()).invoke();
@@ -132,7 +119,7 @@
throw new RemoteException();
};
- mServiceDispatcher.setRendererService(mock(IRendererService.class));
+ mServiceDispatcher.setOnBindingListener(() -> true);
Integer result = mServiceDispatcher.fetch(234, call);
verify(mErrorHandler, times(1))
diff --git a/compose/ui/ui-text/src/androidAndroidTest/kotlin/androidx/compose/ui/text/platform/AndroidParagraphTest.kt b/compose/ui/ui-text/src/androidAndroidTest/kotlin/androidx/compose/ui/text/platform/AndroidParagraphTest.kt
index fd62ae0..32d6216 100644
--- a/compose/ui/ui-text/src/androidAndroidTest/kotlin/androidx/compose/ui/text/platform/AndroidParagraphTest.kt
+++ b/compose/ui/ui-text/src/androidAndroidTest/kotlin/androidx/compose/ui/text/platform/AndroidParagraphTest.kt
@@ -9,8 +9,6 @@
import android.text.style.LocaleSpan
import android.text.style.RelativeSizeSpan
import android.text.style.ScaleXSpan
-import android.text.style.StrikethroughSpan
-import android.text.style.UnderlineSpan
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Canvas
import androidx.compose.ui.graphics.Color
@@ -29,6 +27,7 @@
import androidx.compose.ui.text.android.style.LetterSpacingSpanPx
import androidx.compose.ui.text.android.style.ShadowSpan
import androidx.compose.ui.text.android.style.SkewXSpan
+import androidx.compose.ui.text.android.style.TextDecorationSpan
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.text.font.FontSynthesis
@@ -165,7 +164,13 @@
)
assertThat(paragraph.charSequence.toString()).isEqualTo(text)
- assertThat(paragraph.charSequence).hasSpan(StrikethroughSpan::class, 0, text.length)
+ assertThat(paragraph.charSequence).hasSpan(
+ spanClazz = TextDecorationSpan::class,
+ start = 0,
+ end = text.length
+ ) {
+ !it.isUnderlineText && it.isStrikethroughText
+ }
}
@Test
@@ -180,7 +185,13 @@
)
assertThat(paragraph.charSequence.toString()).isEqualTo(text)
- assertThat(paragraph.charSequence).hasSpan(UnderlineSpan::class, 0, text.length)
+ assertThat(paragraph.charSequence).hasSpan(
+ spanClazz = TextDecorationSpan::class,
+ start = 0,
+ end = text.length
+ ) {
+ it.isUnderlineText && !it.isStrikethroughText
+ }
}
@Test
@@ -195,7 +206,13 @@
)
assertThat(paragraph.charSequence.toString()).isEqualTo(text)
- assertThat(paragraph.charSequence).hasSpan(StrikethroughSpan::class, 0, "abc".length)
+ assertThat(paragraph.charSequence).hasSpan(
+ spanClazz = TextDecorationSpan::class,
+ start = 0,
+ end = "abc".length
+ ) {
+ !it.isUnderlineText && it.isStrikethroughText
+ }
}
@Test
@@ -210,7 +227,13 @@
)
assertThat(paragraph.charSequence.toString()).isEqualTo(text)
- assertThat(paragraph.charSequence).hasSpan(UnderlineSpan::class, 0, "abc".length)
+ assertThat(paragraph.charSequence).hasSpan(
+ spanClazz = TextDecorationSpan::class,
+ start = 0,
+ end = "abc".length
+ ) {
+ it.isUnderlineText && !it.isStrikethroughText
+ }
}
@Test
@@ -227,8 +250,13 @@
)
assertThat(paragraph.charSequence.toString()).isEqualTo(text)
- assertThat(paragraph.charSequence).hasSpan(UnderlineSpan::class, 0, "abc".length)
- assertThat(paragraph.charSequence).hasSpan(StrikethroughSpan::class, 0, "abc".length)
+ assertThat(paragraph.charSequence).hasSpan(
+ spanClazz = TextDecorationSpan::class,
+ start = 0,
+ end = "abc".length
+ ) {
+ it.isUnderlineText && it.isStrikethroughText
+ }
}
@Test
@@ -551,7 +579,7 @@
}
@Test
- fun testAnnotatedString_setTextGeometricTransformWithNull_noSpanSet() {
+ fun testAnnotatedString_setDefaultTextGeometricTransform() {
val text = "abcde"
val spanStyle = SpanStyle(textGeometricTransform = TextGeometricTransform())
@@ -561,8 +589,16 @@
width = 100.0f // width is not important
)
- assertThat(paragraph.charSequence).spans(ScaleXSpan::class).isEmpty()
- assertThat(paragraph.charSequence).spans(SkewXSpan::class).isEmpty()
+ assertThat(paragraph.charSequence).hasSpan(ScaleXSpan::class, 0, text.length) {
+ it.scaleX == 1.0f
+ }
+ assertThat(paragraph.charSequence).hasSpan(
+ spanClazz = SkewXSpan::class,
+ start = 0,
+ end = text.length
+ ) {
+ it.skewX == 0.0f
+ }
}
@Test
@@ -584,7 +620,9 @@
assertThat(paragraph.charSequence).hasSpan(ScaleXSpan::class, 0, text.length) {
it.scaleX == scaleX
}
- assertThat(paragraph.charSequence).spans(SkewXSpan::class).isEmpty()
+ assertThat(paragraph.charSequence).hasSpan(SkewXSpan::class, 0, text.length) {
+ it.skewX == 0.0f
+ }
}
@Test
@@ -602,7 +640,9 @@
assertThat(paragraph.charSequence).hasSpan(SkewXSpan::class, 0, text.length) {
it.skewX == skewX
}
- assertThat(paragraph.charSequence).spans(ScaleXSpan::class).isEmpty()
+ assertThat(paragraph.charSequence).hasSpan(ScaleXSpan::class, 0, text.length) {
+ it.scaleX == 1.0f
+ }
}
@Test
diff --git a/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/AndroidAccessibilitySpannableString.android.kt b/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/AndroidAccessibilitySpannableString.android.kt
index fb3c45d5..8bc21b2 100644
--- a/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/AndroidAccessibilitySpannableString.android.kt
+++ b/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/AndroidAccessibilitySpannableString.android.kt
@@ -21,8 +21,10 @@
import android.text.SpannableString
import android.text.Spanned
import android.text.style.ScaleXSpan
+import android.text.style.StrikethroughSpan
import android.text.style.StyleSpan
import android.text.style.TypefaceSpan
+import android.text.style.UnderlineSpan
import androidx.annotation.DoNotInline
import androidx.annotation.RequiresApi
import androidx.annotation.RestrictTo
@@ -39,8 +41,8 @@
import androidx.compose.ui.text.platform.extensions.setColor
import androidx.compose.ui.text.platform.extensions.setFontSize
import androidx.compose.ui.text.platform.extensions.setLocaleList
-import androidx.compose.ui.text.platform.extensions.setTextDecoration
import androidx.compose.ui.text.platform.extensions.toSpan
+import androidx.compose.ui.text.style.TextDecoration
import androidx.compose.ui.unit.Density
import androidx.compose.ui.util.fastForEach
@@ -126,12 +128,29 @@
}
}
- setTextDecoration(spanStyle.textDecoration, start, end)
+ if (spanStyle.textDecoration != null) {
+ // This doesn't match how we rendering the styles. When TextDecoration.None is set, it
+ // should remove the underline and lineThrough effect on the given range. Here we didn't
+ // remove any previously applied spans yet.
+ if (TextDecoration.Underline in spanStyle.textDecoration) {
+ setSpan(
+ UnderlineSpan(),
+ start,
+ end,
+ Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+ )
+ }
+ if (TextDecoration.LineThrough in spanStyle.textDecoration) {
+ setSpan(
+ StrikethroughSpan(),
+ start,
+ end,
+ Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+ )
+ }
+ }
- if (
- spanStyle.textGeometricTransform != null &&
- spanStyle.textGeometricTransform.scaleX != 1f
- ) {
+ if (spanStyle.textGeometricTransform != null) {
setSpan(
ScaleXSpan(spanStyle.textGeometricTransform.scaleX),
start,
diff --git a/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/extensions/SpannableExtensions.android.kt b/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/extensions/SpannableExtensions.android.kt
index 17f672c..f109647 100644
--- a/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/extensions/SpannableExtensions.android.kt
+++ b/compose/ui/ui-text/src/androidMain/kotlin/androidx/compose/ui/text/platform/extensions/SpannableExtensions.android.kt
@@ -27,8 +27,6 @@
import android.text.style.MetricAffectingSpan
import android.text.style.RelativeSizeSpan
import android.text.style.ScaleXSpan
-import android.text.style.StrikethroughSpan
-import android.text.style.UnderlineSpan
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Shadow
import androidx.compose.ui.graphics.isSpecified
@@ -44,6 +42,7 @@
import androidx.compose.ui.text.android.style.LineHeightSpan
import androidx.compose.ui.text.android.style.ShadowSpan
import androidx.compose.ui.text.android.style.SkewXSpan
+import androidx.compose.ui.text.android.style.TextDecorationSpan
import androidx.compose.ui.text.android.style.TypefaceSpan
import androidx.compose.ui.text.fastFilter
import androidx.compose.ui.text.font.FontStyle
@@ -393,12 +392,8 @@
end: Int
) {
textGeometricTransform?.let {
- if (it.scaleX != 1.0f) {
- setSpan(ScaleXSpan(it.scaleX), start, end)
- }
- if (it.skewX != 0f) {
- setSpan(SkewXSpan(it.skewX), start, end)
- }
+ setSpan(ScaleXSpan(it.scaleX), start, end)
+ setSpan(SkewXSpan(it.skewX), start, end)
}
}
@@ -427,14 +422,14 @@
}
}
+@OptIn(InternalPlatformTextApi::class)
internal fun Spannable.setTextDecoration(textDecoration: TextDecoration?, start: Int, end: Int) {
textDecoration?.let {
- if (TextDecoration.Underline in it) {
- setSpan(UnderlineSpan(), start, end)
- }
- if (TextDecoration.LineThrough in it) {
- setSpan(StrikethroughSpan(), start, end)
- }
+ val textDecorationSpan = TextDecorationSpan(
+ isUnderlineText = TextDecoration.Underline in it,
+ isStrikethroughText = TextDecoration.LineThrough in it
+ )
+ setSpan(textDecorationSpan, start, end)
}
}
diff --git a/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/HitPathTrackerTest.kt b/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/HitPathTrackerTest.kt
index 622151f..d74228e 100644
--- a/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/HitPathTrackerTest.kt
+++ b/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/HitPathTrackerTest.kt
@@ -443,10 +443,12 @@
@Test
fun dispatchChanges_noNodes_nothingChanges() {
- val (result, _) = hitPathTracker.dispatchChanges(internalPointerEventOf(down(5)))
+ val internalPointerEvent = internalPointerEventOf(down(5))
+
+ hitPathTracker.dispatchChanges(internalPointerEvent)
PointerInputChangeSubject
- .assertThat(result.changes.values.first())
+ .assertThat(internalPointerEvent.changes.values.first())
.isStructurallyEqualTo(down(5))
}
@@ -463,10 +465,12 @@
hitPathTracker.addHitPath(PointerId(13), listOf(pif1))
- val (result, _) = hitPathTracker.dispatchChanges(internalPointerEventOf(down(13)))
+ val internalPointerEvent = internalPointerEventOf(down(13))
+
+ hitPathTracker.dispatchChanges(internalPointerEvent)
PointerInputChangeSubject
- .assertThat(result.changes.values.first())
+ .assertThat(internalPointerEvent.changes.values.first())
.isStructurallyEqualTo(down(13).apply { consumeDownChange() })
}
@@ -508,7 +512,9 @@
val expectedChange = actualChange.deepCopy()
val consumedExpectedChange = actualChange.deepCopy().apply { consumePositionChange() }
- val (result, _) = hitPathTracker.dispatchChanges(internalPointerEventOf(actualChange))
+ val internalPointerEvent = internalPointerEventOf(actualChange)
+
+ hitPathTracker.dispatchChanges(internalPointerEvent)
val log1 = log.getOnPointerEventLog()
.filter { it.pass == PointerEventPass.Initial || it.pass == PointerEventPass.Main }
@@ -570,7 +576,7 @@
assertThat(log1[5].pass).isEqualTo(PointerEventPass.Main)
PointerInputChangeSubject
- .assertThat(result.changes.values.first())
+ .assertThat(internalPointerEvent.changes.values.first())
.isStructurallyEqualTo(
consumedExpectedChange
)
@@ -628,9 +634,9 @@
val consumedExpectedEvent1 = expectedEvent1.deepCopy().apply { consumePositionChange() }
val consumedExpectedEvent2 = expectedEvent2.deepCopy().apply { consumePositionChange() }
- val (result, _) = hitPathTracker.dispatchChanges(
- internalPointerEventOf(actualEvent1, actualEvent2)
- )
+ val internalPointerEvent = internalPointerEventOf(actualEvent1, actualEvent2)
+
+ hitPathTracker.dispatchChanges(internalPointerEvent)
val log1 = log.getOnPointerEventLog()
.filter { it.pass == PointerEventPass.Initial || it.pass == PointerEventPass.Main }
@@ -712,14 +718,14 @@
)
assertThat(log2[3].pass).isEqualTo(PointerEventPass.Main)
- assertThat(result.changes).hasSize(2)
+ assertThat(internalPointerEvent.changes).hasSize(2)
PointerInputChangeSubject
- .assertThat(result.changes[actualEvent1.id])
+ .assertThat(internalPointerEvent.changes[actualEvent1.id])
.isStructurallyEqualTo(
consumedExpectedEvent1
)
PointerInputChangeSubject
- .assertThat(result.changes[actualEvent2.id])
+ .assertThat(internalPointerEvent.changes[actualEvent2.id])
.isStructurallyEqualTo(
consumedExpectedEvent2
)
@@ -770,9 +776,9 @@
val consumedEvent1 = expectedEvent1.deepCopy().apply { consumePositionChange() }
val consumedEvent2 = expectedEvent2.deepCopy().apply { consumePositionChange() }
- val (result, _) = hitPathTracker.dispatchChanges(
- internalPointerEventOf(actualEvent1, actualEvent2)
- )
+ val internalPointerEvent = internalPointerEventOf(actualEvent1, actualEvent2)
+
+ hitPathTracker.dispatchChanges(internalPointerEvent)
val log1 = log.getOnPointerEventLog()
.filter { it.pass == PointerEventPass.Initial || it.pass == PointerEventPass.Main }
@@ -823,13 +829,13 @@
)
assertThat(log1[5].pass).isEqualTo(PointerEventPass.Main)
- assertThat(result.changes).hasSize(2)
+ assertThat(internalPointerEvent.changes).hasSize(2)
PointerInputChangeSubject
- .assertThat(result.changes[actualEvent1.id])
+ .assertThat(internalPointerEvent.changes[actualEvent1.id])
.isStructurallyEqualTo(consumedEvent1)
PointerInputChangeSubject
- .assertThat(result.changes[actualEvent2.id])
+ .assertThat(internalPointerEvent.changes[actualEvent2.id])
.isStructurallyEqualTo(consumedEvent2)
}
@@ -866,9 +872,9 @@
val consumedEvent1 = expectedEvent1.deepCopy().apply { consumePositionChange() }
val consumedEvent2 = expectedEvent2.deepCopy().apply { consumePositionChange() }
- val (result, _) = hitPathTracker.dispatchChanges(
- internalPointerEventOf(actualEvent1, actualEvent2)
- )
+ val internalPointerEvent = internalPointerEventOf(actualEvent1, actualEvent2)
+
+ hitPathTracker.dispatchChanges(internalPointerEvent)
val log1 = log.getOnPointerEventLog()
.filter { it.pass == PointerEventPass.Initial || it.pass == PointerEventPass.Main }
@@ -912,14 +918,14 @@
)
assertThat(log1[3].pass).isEqualTo(PointerEventPass.Main)
- assertThat(result.changes).hasSize(2)
+ assertThat(internalPointerEvent.changes).hasSize(2)
PointerInputChangeSubject
- .assertThat(result.changes[actualEvent1.id])
+ .assertThat(internalPointerEvent.changes[actualEvent1.id])
.isStructurallyEqualTo(
consumedEvent1
)
PointerInputChangeSubject
- .assertThat(result.changes[actualEvent2.id])
+ .assertThat(internalPointerEvent.changes[actualEvent2.id])
.isStructurallyEqualTo(
consumedEvent2
)
@@ -2842,7 +2848,7 @@
@Test
fun dispatchChanges_noNodes_reportsWasDispatchedToNothing() {
- val (_, hitSomething) = hitPathTracker.dispatchChanges(internalPointerEventOf(down(0)))
+ val hitSomething = hitPathTracker.dispatchChanges(internalPointerEventOf(down(0)))
assertThat(hitSomething).isFalse()
}
@@ -2851,7 +2857,7 @@
val pif = PointerInputFilterMock()
hitPathTracker.addHitPath(PointerId(13), listOf(pif))
- val (_, hitSomething) = hitPathTracker.dispatchChanges(internalPointerEventOf(down(13)))
+ val hitSomething = hitPathTracker.dispatchChanges(internalPointerEventOf(down(13)))
assertThat(hitSomething).isTrue()
}
@@ -2861,7 +2867,7 @@
val pif = PointerInputFilterMock()
hitPathTracker.addHitPath(PointerId(13), listOf(pif))
- val (_, hitSomething) = hitPathTracker.dispatchChanges(internalPointerEventOf(down(69)))
+ val hitSomething = hitPathTracker.dispatchChanges(internalPointerEventOf(down(69)))
assertThat(hitSomething).isFalse()
}
@@ -3109,7 +3115,7 @@
if (actualNode.children.size != expectedNode.children.size) {
return false
}
- for (child in actualNode.children) {
+ actualNode.children.forEach { child ->
check = check && expectedNode.children.any {
areEqual(child, it)
}
@@ -3137,7 +3143,7 @@
if (actualNode.children.size != expectedNode.children.size) {
return false
}
- for (child in actualNode.children) {
+ actualNode.children.forEach { child ->
check = check && expectedNode.children.any {
areEqual(child, it)
}
diff --git a/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapterTest.kt b/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapterTest.kt
index b55dd28..db78ad7 100644
--- a/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapterTest.kt
+++ b/compose/ui/ui/src/androidAndroidTest/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapterTest.kt
@@ -1050,25 +1050,32 @@
arrayOf(PointerCoords(30f, 31f))
)
+ // Test the different events sequentially, since the returned event contains a list that
+ // will be reused by convertToPointerInputEvent for performance, so it shouldn't be held
+ // for longer than needed during the sequential dispatch.
+
val pointerInputEventDown1 = motionEventAdapter.convertToPointerInputEvent(down1)
- val pointerInputEventUp1 = motionEventAdapter.convertToPointerInputEvent(up1)
- val pointerInputEventDown2 = motionEventAdapter.convertToPointerInputEvent(down2)
- val pointerInputEventUp2 = motionEventAdapter.convertToPointerInputEvent(up2)
- val pointerInputEventDown3 = motionEventAdapter.convertToPointerInputEvent(down3)
- val pointerInputEventUp3 = motionEventAdapter.convertToPointerInputEvent(up3)
-
assertThat(pointerInputEventDown1).isNotNull()
- assertThat(pointerInputEventUp1).isNotNull()
- assertThat(pointerInputEventDown2).isNotNull()
- assertThat(pointerInputEventUp2).isNotNull()
- assertThat(pointerInputEventDown3).isNotNull()
- assertThat(pointerInputEventUp3).isNotNull()
-
assertThat(pointerInputEventDown1!!.pointers[0].id).isEqualTo(PointerId(0))
+
+ val pointerInputEventUp1 = motionEventAdapter.convertToPointerInputEvent(up1)
+ assertThat(pointerInputEventUp1).isNotNull()
assertThat(pointerInputEventUp1!!.pointers[0].id).isEqualTo(PointerId(0))
+
+ val pointerInputEventDown2 = motionEventAdapter.convertToPointerInputEvent(down2)
+ assertThat(pointerInputEventDown2).isNotNull()
assertThat(pointerInputEventDown2!!.pointers[0].id).isEqualTo(PointerId(1))
+
+ val pointerInputEventUp2 = motionEventAdapter.convertToPointerInputEvent(up2)
+ assertThat(pointerInputEventUp2).isNotNull()
assertThat(pointerInputEventUp2!!.pointers[0].id).isEqualTo(PointerId(1))
+
+ val pointerInputEventDown3 = motionEventAdapter.convertToPointerInputEvent(down3)
+ assertThat(pointerInputEventDown3).isNotNull()
assertThat(pointerInputEventDown3!!.pointers[0].id).isEqualTo(PointerId(2))
+
+ val pointerInputEventUp3 = motionEventAdapter.convertToPointerInputEvent(up3)
+ assertThat(pointerInputEventUp3).isNotNull()
assertThat(pointerInputEventUp3!!.pointers[0].id).isEqualTo(PointerId(2))
}
@@ -1119,21 +1126,26 @@
)
)
+ // Test the different events sequentially, since the returned event contains a list that
+ // will be reused by convertToPointerInputEvent for performance, so it shouldn't be held
+ // for longer than needed during the sequential dispatch.
+
val pointerInputEventDown1 = motionEventAdapter.convertToPointerInputEvent(down1)
- val pointerInputEventDown2 = motionEventAdapter.convertToPointerInputEvent(down2)
- val pointerInputEventDown3 = motionEventAdapter.convertToPointerInputEvent(down3)
assertThat(pointerInputEventDown1).isNotNull()
- assertThat(pointerInputEventDown2).isNotNull()
- assertThat(pointerInputEventDown3).isNotNull()
-
assertThat(pointerInputEventDown1!!.pointers).hasSize(1)
assertThat(pointerInputEventDown1.pointers[0].id).isEqualTo(PointerId(0))
+ val pointerInputEventDown2 = motionEventAdapter.convertToPointerInputEvent(down2)
+
+ assertThat(pointerInputEventDown2).isNotNull()
assertThat(pointerInputEventDown2!!.pointers).hasSize(2)
assertThat(pointerInputEventDown2.pointers[0].id).isEqualTo(PointerId(0))
assertThat(pointerInputEventDown2.pointers[1].id).isEqualTo(PointerId(1))
+ val pointerInputEventDown3 = motionEventAdapter.convertToPointerInputEvent(down3)
+
+ assertThat(pointerInputEventDown3).isNotNull()
assertThat(pointerInputEventDown3!!.pointers).hasSize(3)
assertThat(pointerInputEventDown2.pointers[0].id).isEqualTo(PointerId(0))
assertThat(pointerInputEventDown2.pointers[1].id).isEqualTo(PointerId(1))
diff --git a/compose/ui/ui/src/androidMain/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapter.android.kt b/compose/ui/ui/src/androidMain/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapter.android.kt
index 1284beb..7ebf120 100644
--- a/compose/ui/ui/src/androidMain/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapter.android.kt
+++ b/compose/ui/ui/src/androidMain/kotlin/androidx/compose/ui/input/pointer/MotionEventAdapter.android.kt
@@ -43,6 +43,8 @@
@VisibleForTesting
internal val motionEventToComposePointerIdMap: MutableMap<Int, PointerId> = mutableMapOf()
+ private val pointers: MutableList<PointerInputEventData> = mutableListOf()
+
/**
* Converts a single [MotionEvent] from an Android event stream into a [PointerInputEvent], or
* null if the [MotionEvent.getActionMasked] is [ACTION_CANCEL].
@@ -76,12 +78,10 @@
else -> null
}
- // TODO(shepshapard): Avoid allocating for every event.
- val pointers: MutableList<PointerInputEventData> = mutableListOf()
+ pointers.clear()
// This converts the MotionEvent into a list of PointerInputEventData, and updates
// internal record keeping.
- @Suppress("NAME_SHADOWING")
for (i in 0 until motionEvent.pointerCount) {
pointers.add(
createPointerInputEventData(
diff --git a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/HitPathTracker.kt b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/HitPathTracker.kt
index ea55590..8bf9f48 100644
--- a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/HitPathTracker.kt
+++ b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/HitPathTracker.kt
@@ -16,6 +16,8 @@
package androidx.compose.ui.input.pointer
+import androidx.compose.runtime.collection.MutableVector
+import androidx.compose.runtime.collection.mutableVectorOf
import androidx.compose.ui.layout.LayoutCoordinates
import androidx.compose.ui.node.InternalCoreApi
@@ -32,23 +34,6 @@
/*@VisibleForTesting*/
internal val root: NodeParent = NodeParent()
- private val retainedHitPaths: MutableSet<PointerId> = mutableSetOf()
-
- internal interface DispatchChangesRetVal {
- operator fun component1(): InternalPointerEvent
- operator fun component2(): Boolean
- }
-
- private class DispatchChangesRetValImpl : DispatchChangesRetVal {
- lateinit var internalPointerEvent: InternalPointerEvent
- var wasDispatchedToSomething: Boolean = false
- override operator fun component1() = internalPointerEvent
- override operator fun component2() = wasDispatchedToSomething
- }
-
- // See https://youtrack.jetbrains.com/issue/KT-39905.
- private val dispatchChangesRetVal = DispatchChangesRetValImpl()
-
/**
* Associates a [pointerId] to a list of hit [pointerInputFilters] and keeps track of them.
*
@@ -67,9 +52,11 @@
eachPin@ for (i in pointerInputFilters.indices) {
val pointerInputFilter = pointerInputFilters[i]
if (merging) {
- val node = parent.children.find { it.pointerInputFilter == pointerInputFilter }
+ val node = parent.children.firstOrNull {
+ it.pointerInputFilter == pointerInputFilter
+ }
if (node != null) {
- node.pointerIds.add(pointerId)
+ if (pointerId !in node.pointerIds) node.pointerIds.add(pointerId)
parent = node
continue@eachPin
} else {
@@ -89,26 +76,17 @@
* therefore no longer associated with any pointer ids.
*/
fun removeHitPath(pointerId: PointerId) {
- removeHitPathInternal(pointerId)
- removeHitPathInternal(pointerId)
+ root.recursivelyRemovePointerId(pointerId)
}
/**
* Dispatches [internalPointerEvent] through the hierarchy.
*
- * Returns a [DispatchChangesRetVal] that should not be referenced directly, but instead
- * should be destrutured immediately. Each instance of [HitPathTracker] reuses a single
- * [DispatchChangesRetVal] and mutates it for each return for performance reasons.
- *
- * [DispatchChangesRetVal.component1] references the resulting changes after dispatch.
- * [DispatchChangesRetVal.component2] is true if the dispatch reached at least one
- * [PointerInputModifier].
- *
* @param internalPointerEvent The change to dispatch.
*
- * @return The DispatchChangesRetVal that should be destructured immediately.
+ * @return whether this event was dispatched to a [PointerInputFilter]
*/
- fun dispatchChanges(internalPointerEvent: InternalPointerEvent): DispatchChangesRetVal {
+ fun dispatchChanges(internalPointerEvent: InternalPointerEvent): Boolean {
var dispatchHit = root.dispatchMainEventPass(
internalPointerEvent.changes,
rootCoordinates,
@@ -116,9 +94,7 @@
)
dispatchHit = root.dispatchFinalEventPass() || dispatchHit
- dispatchChangesRetVal.wasDispatchedToSomething = dispatchHit
- dispatchChangesRetVal.internalPointerEvent = internalPointerEvent
- return dispatchChangesRetVal
+ return dispatchHit
}
/**
@@ -128,7 +104,6 @@
* data.
*/
fun processCancel() {
- retainedHitPaths.clear()
root.dispatchCancel()
root.clear()
}
@@ -142,13 +117,6 @@
fun removeDetachedPointerInputFilters() {
root.removeDetachedPointerInputFilters()
}
-
- /**
- * Actually removes hit paths.
- */
- private fun removeHitPathInternal(pointerId: PointerId) {
- root.removePointerId(pointerId)
- }
}
/**
@@ -159,7 +127,7 @@
/*@VisibleForTesting*/
@OptIn(InternalCoreApi::class)
internal open class NodeParent {
- val children: MutableSet<Node> = mutableSetOf()
+ val children: MutableVector<Node> = mutableVectorOf()
/**
* Dispatches [changes] down the tree, for the initial and main pass.
@@ -221,54 +189,33 @@
* Removes all child [Node]s that are no longer attached to the compose tree.
*/
fun removeDetachedPointerInputFilters() {
- children.removeAndProcess(
- removeIf = {
- !it.pointerInputFilter.isAttached
- },
- ifRemoved = {
- it.dispatchCancel()
- },
- ifKept = {
- it.removeDetachedPointerInputFilters()
+ var index = 0
+ while (index < children.size) {
+ val child = children[index]
+ if (!child.pointerInputFilter.isAttached) {
+ children.removeAt(index)
+ child.dispatchCancel()
+ } else {
+ index++
+ child.removeDetachedPointerInputFilters()
}
- )
+ }
}
/**
* Removes the tracking of [pointerId] and removes all child [Node]s that are no longer
- * tracking
- * any [PointerId]s.
+ * tracking any [PointerId]s.
*/
- fun removePointerId(pointerId: PointerId) {
- children.forEach {
- it.pointerIds.remove(pointerId)
- }
- children.removeAll {
- it.pointerIds.isEmpty()
- }
- children.forEach {
- it.removePointerId(pointerId)
- }
- }
-
- /**
- * With each item, if calling [removeIf] with it is true, removes the item from [this] and calls
- * [ifRemoved] with it, otherwise calls [ifKept] with it.
- */
- private fun <T> MutableIterable<T>.removeAndProcess(
- removeIf: (T) -> Boolean,
- ifRemoved: (T) -> Unit,
- ifKept: (T) -> Unit
- ) {
- with(iterator()) {
- while (hasNext()) {
- val next = next()
- if (removeIf(next)) {
- remove()
- ifRemoved(next)
- } else {
- ifKept(next)
- }
+ fun recursivelyRemovePointerId(pointerId: PointerId) {
+ var index = 0
+ while (index < children.size) {
+ val child = children[index]
+ child.pointerIds.remove(pointerId)
+ if (child.pointerIds.isEmpty()) {
+ children.removeAt(index)
+ } else {
+ child.recursivelyRemovePointerId(pointerId)
+ index++
}
}
}
@@ -282,7 +229,13 @@
@OptIn(InternalCoreApi::class)
internal class Node(val pointerInputFilter: PointerInputFilter) : NodeParent() {
- val pointerIds: MutableSet<PointerId> = mutableSetOf()
+ // Note: this is essentially a set, and writes should be guarded accordingly. We use a
+ // MutableVector here instead since a set ends up being quite heavy, and calls to
+ // set.contains() show up noticeably (~1%) in traces. Since the maximum size of this vector
+ // is small (due to the limited amount of concurrent PointerIds there _could_ be), iterating
+ // through the small vector in most cases should have a lower performance impact than using a
+ // set.
+ val pointerIds: MutableVector<PointerId> = mutableVectorOf()
/**
* Cached properties that will be set before the main event pass, and reset after the final
diff --git a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/PointerInputEventProcessor.kt b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/PointerInputEventProcessor.kt
index 54db299..35ccd12 100644
--- a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/PointerInputEventProcessor.kt
+++ b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/PointerInputEventProcessor.kt
@@ -34,6 +34,7 @@
private val hitPathTracker = HitPathTracker(root.coordinates)
private val pointerInputChangeEventProducer = PointerInputChangeEventProducer()
+ private val hitResult: MutableList<PointerInputFilter> = mutableListOf()
/**
* Receives [PointerInputEvent]s and process them through the tree rooted on [root].
@@ -54,44 +55,41 @@
val internalPointerEvent =
pointerInputChangeEventProducer.produce(pointerEvent, positionCalculator)
- // TODO(shepshapard): Create fast forEach for maps?
-
// Add new hit paths to the tracker due to down events.
- internalPointerEvent
- .changes
- .filter { (_, pointerInputChange) -> pointerInputChange.changedToDownIgnoreConsumed() }
- .forEach { (_, pointerInputChange) ->
- val hitResult: MutableList<PointerInputFilter> = mutableListOf()
+ internalPointerEvent.changes.values.forEach { pointerInputChange ->
+ if (pointerInputChange.changedToDownIgnoreConsumed()) {
root.hitTest(
pointerInputChange.position,
hitResult
)
if (hitResult.isNotEmpty()) {
hitPathTracker.addHitPath(pointerInputChange.id, hitResult)
+ hitResult.clear()
}
}
+ }
// Remove [PointerInputFilter]s that are no longer valid and refresh the offset information
// for those that are.
hitPathTracker.removeDetachedPointerInputFilters()
// Dispatch to PointerInputFilters
- val (resultingChanges, dispatchedToSomething) =
- hitPathTracker.dispatchChanges(internalPointerEvent)
+ val dispatchedToSomething = hitPathTracker.dispatchChanges(internalPointerEvent)
- // Remove hit paths from the tracker due to up events.
- internalPointerEvent
- .changes
- .filter { (_, pointerInputChange) -> pointerInputChange.changedToUpIgnoreConsumed() }
- .forEach { (_, pointerInputChange) ->
+ var anyMovementConsumed = false
+
+ // Remove hit paths from the tracker due to up events, and calculate if we have consumed
+ // any movement
+ internalPointerEvent.changes.values.forEach { pointerInputChange ->
+ if (pointerInputChange.changedToUpIgnoreConsumed()) {
hitPathTracker.removeHitPath(pointerInputChange.id)
}
+ if (pointerInputChange.positionChangeConsumed()) {
+ anyMovementConsumed = true
+ }
+ }
- // TODO(shepshapard): Don't allocate on every call.
- return ProcessResult(
- dispatchedToSomething,
- resultingChanges.changes.any { (_, value) -> value.positionChangeConsumed() }
- )
+ return ProcessResult(dispatchedToSomething, anyMovementConsumed)
}
/**
@@ -154,8 +152,7 @@
previousPointerInputData[it.id] = PointerInputData(
it.uptime,
it.positionOnScreen,
- it.down,
- it.type
+ it.down
)
} else {
previousPointerInputData.remove(it.id)
@@ -167,15 +164,14 @@
/**
* Clears all tracked information.
*/
- internal fun clear() {
+ fun clear() {
previousPointerInputData.clear()
}
private class PointerInputData(
val uptime: Long,
val positionOnScreen: Offset,
- val down: Boolean,
- val type: PointerType
+ val down: Boolean
)
}
@@ -183,7 +179,6 @@
* The result of a call to [PointerInputEventProcessor.process].
*/
// TODO(shepshpard): Not sure if storing these values in a int is most efficient overall.
-@Suppress("EXPERIMENTAL_FEATURE_WARNING")
internal inline class ProcessResult(private val value: Int) {
val dispatchedToAPointerInputModifier
get() = (value and 1) != 0
diff --git a/core/core/src/androidTest/java/androidx/core/view/AccessibilityDelegateCompatTest.java b/core/core/src/androidTest/java/androidx/core/view/AccessibilityDelegateCompatTest.java
index b6767d5..9ecc7281 100644
--- a/core/core/src/androidTest/java/androidx/core/view/AccessibilityDelegateCompatTest.java
+++ b/core/core/src/androidTest/java/androidx/core/view/AccessibilityDelegateCompatTest.java
@@ -169,7 +169,7 @@
@Test
@SdkSuppress(minSdkVersion = 19, maxSdkVersion = 27)
- @FlakyTest
+ @FlakyTest(bugId = 187190911)
public void testAccessibilityPaneTitle_isntTrackedAsPaneWithoutTitle() {
// This test isn't to test the propagation up, just that the event is sent correctly
ViewCompat.setAccessibilityLiveRegion(mView,
diff --git a/leanback/leanback/src/androidTest/java/androidx/leanback/widget/GridWidgetTest.java b/leanback/leanback/src/androidTest/java/androidx/leanback/widget/GridWidgetTest.java
index b6bae78..ce23b2f 100644
--- a/leanback/leanback/src/androidTest/java/androidx/leanback/widget/GridWidgetTest.java
+++ b/leanback/leanback/src/androidTest/java/androidx/leanback/widget/GridWidgetTest.java
@@ -4567,7 +4567,7 @@
assertEquals(0, mGridView.getSelectedPosition());
}
- @FlakyTest
+ @FlakyTest(bugId = 187191618)
@Test
public void testExtraLayoutSpace() throws Throwable {
Intent intent = new Intent();
diff --git a/text/text/src/main/java/androidx/compose/ui/text/android/style/TextDecorationSpan.kt b/text/text/src/main/java/androidx/compose/ui/text/android/style/TextDecorationSpan.kt
new file mode 100644
index 0000000..afa6802
--- /dev/null
+++ b/text/text/src/main/java/androidx/compose/ui/text/android/style/TextDecorationSpan.kt
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.ui.text.android.style
+
+import android.text.TextPaint
+import android.text.style.CharacterStyle
+import androidx.compose.ui.text.android.InternalPlatformTextApi
+
+/**
+ * A span which applies the underline and strike through to the affected text.
+ *
+ * @property isUnderlineText whether to draw the under for the affected text.
+ * @property isStrikethroughText whether to draw strikethrough line for the affected text.
+ * @suppress
+ */
+@InternalPlatformTextApi
+class TextDecorationSpan(
+ val isUnderlineText: Boolean,
+ val isStrikethroughText: Boolean
+) : CharacterStyle() {
+ override fun updateDrawState(textPaint: TextPaint) {
+ textPaint.isUnderlineText = isUnderlineText
+ textPaint.isStrikeThruText = isStrikethroughText
+ }
+}
\ No newline at end of file
