Files
Flexera-Launcher/wmshell/src/com/android/wm/shell/transition/OneShotRemoteHandler.java
T
2024-11-02 10:55:28 +08:00

243 lines
11 KiB
Java

/*
* Copyright (C) 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 com.android.wm.shell.transition;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
import android.view.SurfaceControl;
import android.window.IRemoteTransition;
import android.window.IRemoteTransitionFinishedCallback;
import android.window.RemoteTransition;
import android.window.TransitionInfo;
import android.window.TransitionRequestInfo;
import android.window.WindowAnimationState;
import android.window.WindowContainerTransaction;
import com.android.internal.protolog.common.ProtoLog;
import com.android.wm.shell.common.ShellExecutor;
import com.android.wm.shell.protolog.ShellProtoLogGroup;
/**
* Handler that forwards to a RemoteTransition. It is designed for one-shot use to attach a
* specific remote animation to a specific transition.
*/
public class OneShotRemoteHandler implements Transitions.TransitionHandler {
private final ShellExecutor mMainExecutor;
/** The specific transition that this handler is associated with. Just for validation. */
private IBinder mTransition = null;
/** The remote to delegate animation to */
private RemoteTransition mRemote;
public OneShotRemoteHandler(@NonNull ShellExecutor mainExecutor,
@NonNull RemoteTransition remote) {
mMainExecutor = mainExecutor;
mRemote = remote;
}
public void setTransition(@NonNull IBinder transition) {
mTransition = transition;
}
@Override
public boolean startAnimation(@NonNull IBinder transition, @NonNull TransitionInfo info,
@NonNull SurfaceControl.Transaction startTransaction,
@NonNull SurfaceControl.Transaction finishTransaction,
@NonNull Transitions.TransitionFinishCallback finishCallback) {
if (mTransition != transition) return false;
ProtoLog.v(ShellProtoLogGroup.WM_SHELL_TRANSITIONS, "Using registered One-shot remote"
+ " transition %s for (#%d).", mRemote, info.getDebugId());
final IBinder.DeathRecipient remoteDied = createDeathRecipient(finishCallback);
IRemoteTransitionFinishedCallback cb =
createFinishedCallback(info, finishTransaction, finishCallback, remoteDied);
Transitions.setRunningRemoteTransitionDelegate(mRemote.getAppThread());
try {
if (mRemote.asBinder() != null) {
mRemote.asBinder().linkToDeath(remoteDied, 0 /* flags */);
}
// If the remote is actually in the same process, then make a copy of parameters since
// remote impls assume that they have to clean-up native references.
final SurfaceControl.Transaction remoteStartT = RemoteTransitionHandler.copyIfLocal(
startTransaction, mRemote.getRemoteTransition());
final TransitionInfo remoteInfo =
remoteStartT == startTransaction ? info : info.localRemoteCopy();
mRemote.getRemoteTransition().startAnimation(transition, remoteInfo, remoteStartT, cb);
// assume that remote will apply the start transaction.
startTransaction.clear();
} catch (RemoteException e) {
Log.e(Transitions.TAG, "Error running remote transition.", e);
if (mRemote.asBinder() != null) {
mRemote.asBinder().unlinkToDeath(remoteDied, 0 /* flags */);
}
finishCallback.onTransitionFinished(null /* wct */);
mRemote = null;
}
return true;
}
@Override
public void mergeAnimation(@NonNull IBinder transition, @NonNull TransitionInfo info,
@NonNull SurfaceControl.Transaction t, @NonNull IBinder mergeTarget,
@NonNull Transitions.TransitionFinishCallback finishCallback) {
ProtoLog.v(ShellProtoLogGroup.WM_SHELL_TRANSITIONS, "Merging registered One-shot remote"
+ " transition %s for (#%d).", mRemote, info.getDebugId());
IRemoteTransitionFinishedCallback cb = new IRemoteTransitionFinishedCallback.Stub() {
@Override
public void onTransitionFinished(WindowContainerTransaction wct,
SurfaceControl.Transaction sct) {
ProtoLog.v(ShellProtoLogGroup.WM_SHELL_TRANSITIONS,
"Finished merging one-shot remote transition %s for (#%d).", mRemote,
info.getDebugId());
// We have merged, since we sent the transaction over binder, the one in this
// process won't be cleared if the remote applied it. We don't actually know if the
// remote applied the transaction, but applying twice will break surfaceflinger
// so just assume the worst-case and clear the local transaction.
t.clear();
mMainExecutor.execute(() -> {
finishCallback.onTransitionFinished(wct);
mRemote = null;
});
}
};
try {
// If the remote is actually in the same process, then make a copy of parameters since
// remote impls assume that they have to clean-up native references.
final SurfaceControl.Transaction remoteT =
RemoteTransitionHandler.copyIfLocal(t, mRemote.getRemoteTransition());
final TransitionInfo remoteInfo = remoteT == t ? info : info.localRemoteCopy();
mRemote.getRemoteTransition().mergeAnimation(
transition, remoteInfo, remoteT, mergeTarget, cb);
} catch (RemoteException e) {
Log.e(Transitions.TAG, "Error merging remote transition.", e);
}
}
@Override
public boolean takeOverAnimation(
@NonNull IBinder transition, @NonNull TransitionInfo info,
@NonNull SurfaceControl.Transaction transaction,
@NonNull Transitions.TransitionFinishCallback finishCallback,
@NonNull WindowAnimationState[] states) {
if (mTransition != transition) return false;
ProtoLog.v(ShellProtoLogGroup.WM_SHELL_RECENTS_TRANSITION, "Using registered One-shot "
+ "remote transition %s to take over (#%d).", mRemote, info.getDebugId());
final IBinder.DeathRecipient remoteDied = createDeathRecipient(finishCallback);
IRemoteTransitionFinishedCallback cb = createFinishedCallback(
info, null /* finishTransaction */, finishCallback, remoteDied);
Transitions.setRunningRemoteTransitionDelegate(mRemote.getAppThread());
try {
if (mRemote.asBinder() != null) {
mRemote.asBinder().linkToDeath(remoteDied, 0 /* flags */);
}
// If the remote is actually in the same process, then make a copy of parameters since
// remote impls assume that they have to clean-up native references.
final SurfaceControl.Transaction remoteStartT =
RemoteTransitionHandler.copyIfLocal(transaction, mRemote.getRemoteTransition());
final TransitionInfo remoteInfo =
remoteStartT == transaction ? info : info.localRemoteCopy();
mRemote.getRemoteTransition().takeOverAnimation(
transition, remoteInfo, remoteStartT, cb, states);
// Assume that remote will apply the transaction.
transaction.clear();
return true;
} catch (RemoteException e) {
Log.e(Transitions.TAG, "Error running remote transition takeover.", e);
if (mRemote.asBinder() != null) {
mRemote.asBinder().unlinkToDeath(remoteDied, 0 /* flags */);
}
finishCallback.onTransitionFinished(null /* wct */);
mRemote = null;
}
return false;
}
@Override
@Nullable
public WindowContainerTransaction handleRequest(@NonNull IBinder transition,
@Nullable TransitionRequestInfo request) {
RemoteTransition remote = request.getRemoteTransition();
IRemoteTransition iRemote = remote != null ? remote.getRemoteTransition() : null;
if (iRemote != mRemote.getRemoteTransition()) return null;
mTransition = transition;
ProtoLog.v(ShellProtoLogGroup.WM_SHELL_TRANSITIONS, "RemoteTransition directly requested"
+ " for %s: %s", transition, remote);
return new WindowContainerTransaction();
}
@Override
public void onTransitionConsumed(@NonNull IBinder transition, boolean aborted,
@Nullable SurfaceControl.Transaction finishTransaction) {
try {
mRemote.getRemoteTransition().onTransitionConsumed(transition, aborted);
} catch (RemoteException e) {
Log.e(Transitions.TAG, "Error calling onTransitionConsumed()", e);
}
}
private IBinder.DeathRecipient createDeathRecipient(
Transitions.TransitionFinishCallback finishCallback) {
return () -> {
Log.e(Transitions.TAG, "Remote transition died, finishing");
mMainExecutor.execute(
() -> finishCallback.onTransitionFinished(null /* wct */));
};
}
private IRemoteTransitionFinishedCallback createFinishedCallback(
@NonNull TransitionInfo info,
@Nullable SurfaceControl.Transaction finishTransaction,
@NonNull Transitions.TransitionFinishCallback finishCallback,
@NonNull IBinder.DeathRecipient remoteDied) {
return new IRemoteTransitionFinishedCallback.Stub() {
@Override
public void onTransitionFinished(WindowContainerTransaction wct,
SurfaceControl.Transaction sct) {
ProtoLog.v(ShellProtoLogGroup.WM_SHELL_TRANSITIONS,
"Finished one-shot remote transition %s for (#%d).", mRemote,
info.getDebugId());
if (mRemote.asBinder() != null) {
mRemote.asBinder().unlinkToDeath(remoteDied, 0 /* flags */);
}
if (finishTransaction != null && sct != null) {
finishTransaction.merge(sct);
}
mMainExecutor.execute(() -> {
finishCallback.onTransitionFinished(wct);
mRemote = null;
});
}
};
}
@Override
public String toString() {
return "OneShotRemoteHandler:" + mRemote.getDebugName() + ":"
+ mRemote.getRemoteTransition();
}
}