Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 16a8f596 authored by Ruslan Tkhakokhov's avatar Ruslan Tkhakokhov
Browse files

Make IBackupTransport AIDL async

Make the transport AIDL async and introduce a callback AIDL for passing
back results. A follow-up CL will implement the client-side portion of
the callback class and update BackupTransportClient to use it.

Bug: 202716271
Test: m -j
Change-Id: I79cb376bd2a805bf2739470a3f538207ae6bd9a0
parent d77c92a3
Loading
Loading
Loading
Loading
+104 −55
Original line number Original line Diff line number Diff line
@@ -25,6 +25,11 @@ import android.os.ParcelFileDescriptor;
import android.os.RemoteException;
import android.os.RemoteException;


import com.android.internal.backup.IBackupTransport;
import com.android.internal.backup.IBackupTransport;
import com.android.internal.backup.ITransportStatusCallback;
import com.android.internal.infra.AndroidFuture;

import java.util.Arrays;
import java.util.List;


/**
/**
 * Concrete class that provides a stable-API bridge between IBackupTransport
 * Concrete class that provides a stable-API bridge between IBackupTransport
@@ -659,141 +664,185 @@ public class BackupTransport {
    class TransportImpl extends IBackupTransport.Stub {
    class TransportImpl extends IBackupTransport.Stub {


        @Override
        @Override
        public String name() throws RemoteException {
        public void name(AndroidFuture<String> resultFuture) throws RemoteException {
            return BackupTransport.this.name();
            String result = BackupTransport.this.name();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public Intent configurationIntent() throws RemoteException {
        public void configurationIntent(AndroidFuture<Intent> resultFuture)
            return BackupTransport.this.configurationIntent();
                throws RemoteException {
            Intent result = BackupTransport.this.configurationIntent();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public String currentDestinationString() throws RemoteException {
        public void currentDestinationString(AndroidFuture<String> resultFuture)
            return BackupTransport.this.currentDestinationString();
                throws RemoteException {
            String result = BackupTransport.this.currentDestinationString();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public Intent dataManagementIntent() {
        public void dataManagementIntent(AndroidFuture<Intent> resultFuture)
            return BackupTransport.this.dataManagementIntent();
                throws RemoteException {
            Intent result = BackupTransport.this.dataManagementIntent();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public CharSequence dataManagementIntentLabel() {
        public void dataManagementIntentLabel(AndroidFuture<CharSequence> resultFuture)
            return BackupTransport.this.dataManagementIntentLabel();
                throws RemoteException {
            CharSequence result = BackupTransport.this.dataManagementIntentLabel();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public String transportDirName() throws RemoteException {
        public void transportDirName(AndroidFuture<String> resultFuture) throws RemoteException {
            return BackupTransport.this.transportDirName();
            String result = BackupTransport.this.transportDirName();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public long requestBackupTime() throws RemoteException {
        public void requestBackupTime(AndroidFuture<Long> resultFuture) throws RemoteException {
            return BackupTransport.this.requestBackupTime();
            long result = BackupTransport.this.requestBackupTime();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public int initializeDevice() throws RemoteException {
        public void initializeDevice(ITransportStatusCallback callback) throws RemoteException {
            return BackupTransport.this.initializeDevice();
            int result = BackupTransport.this.initializeDevice();
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public int performBackup(PackageInfo packageInfo, ParcelFileDescriptor inFd, int flags)
        public void performBackup(PackageInfo packageInfo, ParcelFileDescriptor inFd, int flags,
                throws RemoteException {
                ITransportStatusCallback callback) throws RemoteException {
            return BackupTransport.this.performBackup(packageInfo, inFd, flags);
            int result = BackupTransport.this.performBackup(packageInfo, inFd, flags);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public int clearBackupData(PackageInfo packageInfo) throws RemoteException {
        public void clearBackupData(PackageInfo packageInfo, ITransportStatusCallback callback)
            return BackupTransport.this.clearBackupData(packageInfo);
                throws RemoteException {
            int result = BackupTransport.this.clearBackupData(packageInfo);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public int finishBackup() throws RemoteException {
        public void finishBackup(ITransportStatusCallback callback) throws RemoteException {
            return BackupTransport.this.finishBackup();
            int result = BackupTransport.this.finishBackup();
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public RestoreSet[] getAvailableRestoreSets() throws RemoteException {
        public void getAvailableRestoreSets(AndroidFuture<List<RestoreSet>> resultFuture)
            return BackupTransport.this.getAvailableRestoreSets();
                throws RemoteException {
            RestoreSet[] result = BackupTransport.this.getAvailableRestoreSets();
            resultFuture.complete(Arrays.asList(result));
        }
        }


        @Override
        @Override
        public long getCurrentRestoreSet() throws RemoteException {
        public void getCurrentRestoreSet(AndroidFuture<Long> resultFuture)
            return BackupTransport.this.getCurrentRestoreSet();
                throws RemoteException {
            long result = BackupTransport.this.getCurrentRestoreSet();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public int startRestore(long token, PackageInfo[] packages) throws RemoteException {
        public void startRestore(long token, PackageInfo[] packages,
            return BackupTransport.this.startRestore(token, packages);
                ITransportStatusCallback callback)  throws RemoteException {
            int result = BackupTransport.this.startRestore(token, packages);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public RestoreDescription nextRestorePackage() throws RemoteException {
        public void nextRestorePackage(AndroidFuture<RestoreDescription> resultFuture)
            return BackupTransport.this.nextRestorePackage();
                throws RemoteException {
            RestoreDescription result = BackupTransport.this.nextRestorePackage();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public int getRestoreData(ParcelFileDescriptor outFd) throws RemoteException {
        public void getRestoreData(ParcelFileDescriptor outFd,
            return BackupTransport.this.getRestoreData(outFd);
                ITransportStatusCallback callback) throws RemoteException {
            int result = BackupTransport.this.getRestoreData(outFd);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public void finishRestore() throws RemoteException {
        public void finishRestore(ITransportStatusCallback callback)
                throws RemoteException {
            BackupTransport.this.finishRestore();
            BackupTransport.this.finishRestore();
            callback.onOperationComplete();
        }
        }


        @Override
        @Override
        public long requestFullBackupTime() throws RemoteException {
        public void requestFullBackupTime(AndroidFuture<Long> resultFuture)
            return BackupTransport.this.requestFullBackupTime();
                throws RemoteException {
            long result = BackupTransport.this.requestFullBackupTime();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public int performFullBackup(PackageInfo targetPackage, ParcelFileDescriptor socket,
        public void performFullBackup(PackageInfo targetPackage, ParcelFileDescriptor socket,
                int flags) throws RemoteException {
                int flags, ITransportStatusCallback callback) throws RemoteException {
            return BackupTransport.this.performFullBackup(targetPackage, socket, flags);
            int result = BackupTransport.this.performFullBackup(targetPackage, socket, flags);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public int checkFullBackupSize(long size) {
        public void checkFullBackupSize(long size, ITransportStatusCallback callback)
            return BackupTransport.this.checkFullBackupSize(size);
                throws RemoteException {
            int result = BackupTransport.this.checkFullBackupSize(size);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public int sendBackupData(int numBytes) throws RemoteException {
        public void sendBackupData(int numBytes, ITransportStatusCallback callback)
            return BackupTransport.this.sendBackupData(numBytes);
                throws RemoteException {
            int result = BackupTransport.this.sendBackupData(numBytes);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public void cancelFullBackup() throws RemoteException {
        public void cancelFullBackup(ITransportStatusCallback callback) throws RemoteException {
            BackupTransport.this.cancelFullBackup();
            BackupTransport.this.cancelFullBackup();
            callback.onOperationComplete();
        }
        }


        @Override
        @Override
        public boolean isAppEligibleForBackup(PackageInfo targetPackage, boolean isFullBackup)
        public void isAppEligibleForBackup(PackageInfo targetPackage, boolean isFullBackup,
                throws RemoteException {
                AndroidFuture<Boolean> resultFuture) throws RemoteException {
            return BackupTransport.this.isAppEligibleForBackup(targetPackage, isFullBackup);
            boolean result = BackupTransport.this.isAppEligibleForBackup(targetPackage,
                    isFullBackup);
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public long getBackupQuota(String packageName, boolean isFullBackup) {
        public void getBackupQuota(String packageName, boolean isFullBackup,
            return BackupTransport.this.getBackupQuota(packageName, isFullBackup);
                AndroidFuture<Long> resultFuture) throws RemoteException {
            long result = BackupTransport.this.getBackupQuota(packageName, isFullBackup);
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public int getTransportFlags() {
        public void getTransportFlags(AndroidFuture<Integer> resultFuture) throws RemoteException {
            return BackupTransport.this.getTransportFlags();
            int result = BackupTransport.this.getTransportFlags();
            resultFuture.complete(result);
        }
        }


        @Override
        @Override
        public int getNextFullRestoreDataChunk(ParcelFileDescriptor socket) {
        public void getNextFullRestoreDataChunk(ParcelFileDescriptor socket,
            return BackupTransport.this.getNextFullRestoreDataChunk(socket);
                ITransportStatusCallback callback) throws RemoteException {
            int result = BackupTransport.this.getNextFullRestoreDataChunk(socket);
            callback.onOperationCompleteWithStatus(result);
        }
        }


        @Override
        @Override
        public int abortFullRestore() {
        public void abortFullRestore(ITransportStatusCallback callback) throws RemoteException {
            return BackupTransport.this.abortFullRestore();
            int result = BackupTransport.this.abortFullRestore();
            callback.onOperationCompleteWithStatus(result);
        }
        }
    }
    }
}
}
+185 −100

File changed.

Preview size limit exceeded, changes collapsed.

+34 −0
Original line number Original line Diff line number Diff line
/*
 * 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.internal.backup;

/**
* A callback class for {@link IBackupTransport}
*
* {@hide}
*/
oneway interface ITransportStatusCallback {
    /**
    * Callback for methods that complete with an {@code int} status.
    */
    void onOperationCompleteWithStatus(int status);

    /**
    * Callback for methods that complete without a value.
    */
    void onOperationComplete();
}