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

Commit ffee3bc5 authored by Huihong Luo's avatar Huihong Luo Committed by Android (Google) Code Review
Browse files

Revert "Migrate ITransactionCompletedListener to AIDL" 

This reverts commit c50b4988.

Reason for revert: CTS failures, b/262211898

Change-Id: Iaff863f8af98c11dbf852cccad50e55148d87cee
parent c50b4988

libs/binder/include/binder/IInterface.h

+1 −0
Original line number Diff line number Diff line
@@ -230,6 +230,7 @@ constexpr const char* const kManualInterfaces[] = { 
        "android.graphicsenv.IGpuService",

        "android.gui.IConsumerListener",

        "android.gui.IGraphicBufferConsumer",

        "android.gui.ITransactionComposerListener",

        "android.gui.SensorEventConnection",

        "android.gui.SensorServer",

        "android.hardware.ICamera",

libs/gui/ISurfaceComposer.cpp

+0 −1
Original line number Diff line number Diff line
@@ -42,7 +42,6 @@ using namespace aidl::android::hardware::graphics; 


namespace android {



using gui::CallbackId;

using gui::DisplayCaptureArgs;

using gui::IDisplayEventConnection;

using gui::IRegionSamplingListener;

libs/gui/ITransactionCompletedListener.cpp

+68 −3
Original line number Diff line number Diff line
@@ -21,11 +21,22 @@ 
#include <optional>



#include <gui/ISurfaceComposer.h>

#include <gui/ITransactionCompletedListener.h>

#include <gui/LayerState.h>

#include <gui/ListenerStats.h>

#include <private/gui/ParcelUtils.h>



namespace android::gui {

namespace android {



namespace { // Anonymous



enum class Tag : uint32_t {

    ON_TRANSACTION_COMPLETED = IBinder::FIRST_CALL_TRANSACTION,

    ON_RELEASE_BUFFER,

    ON_TRANSACTION_QUEUE_STALLED,

    LAST = ON_TRANSACTION_QUEUE_STALLED,

};



} // Anonymous namespace



status_t FrameEventHistoryStats::writeToParcel(Parcel* output) const {

    status_t err = output->writeUint64(frameNumber);
@@ -263,6 +274,60 @@ ListenerStats ListenerStats::createEmpty( 
    return listenerStats;

}



class BpTransactionCompletedListener : public SafeBpInterface<ITransactionCompletedListener> {

public:

    explicit BpTransactionCompletedListener(const sp<IBinder>& impl)

          : SafeBpInterface<ITransactionCompletedListener>(impl, "BpTransactionCompletedListener") {

    }



    ~BpTransactionCompletedListener() override;



    void onTransactionCompleted(ListenerStats stats) override {

        callRemoteAsync<decltype(&ITransactionCompletedListener::

                                         onTransactionCompleted)>(Tag::ON_TRANSACTION_COMPLETED,

                                                                  stats);

    }



    void onReleaseBuffer(ReleaseCallbackId callbackId, sp<Fence> releaseFence,

                         uint32_t currentMaxAcquiredBufferCount) override {

        callRemoteAsync<decltype(&ITransactionCompletedListener::

                                         onReleaseBuffer)>(Tag::ON_RELEASE_BUFFER, callbackId,

                                                           releaseFence,

                                                           currentMaxAcquiredBufferCount);

    }



    void onTransactionQueueStalled(const String8& reason) override {

        callRemoteAsync<

                decltype(&ITransactionCompletedListener::

                                 onTransactionQueueStalled)>(Tag::ON_TRANSACTION_QUEUE_STALLED,

                                                             reason);

    }

};



// Out-of-line virtual method definitions to trigger vtable emission in this translation unit (see

// clang warning -Wweak-vtables)

BpTransactionCompletedListener::~BpTransactionCompletedListener() = default;



IMPLEMENT_META_INTERFACE(TransactionCompletedListener, "android.gui.ITransactionComposerListener");



status_t BnTransactionCompletedListener::onTransact(uint32_t code, const Parcel& data,

                                                    Parcel* reply, uint32_t flags) {

    if (code < IBinder::FIRST_CALL_TRANSACTION || code > static_cast<uint32_t>(Tag::LAST)) {

        return BBinder::onTransact(code, data, reply, flags);

    }

    auto tag = static_cast<Tag>(code);

    switch (tag) {

        case Tag::ON_TRANSACTION_COMPLETED:

            return callLocalAsync(data, reply,

                                  &ITransactionCompletedListener::onTransactionCompleted);

        case Tag::ON_RELEASE_BUFFER:

            return callLocalAsync(data, reply, &ITransactionCompletedListener::onReleaseBuffer);

        case Tag::ON_TRANSACTION_QUEUE_STALLED:

            return callLocalAsync(data, reply,

                                  &ITransactionCompletedListener::onTransactionQueueStalled);

    }

}



ListenerCallbacks ListenerCallbacks::filter(CallbackId::Type type) const {

    std::vector<CallbackId> filteredCallbackIds;

    for (const auto& callbackId : callbackIds) {
@@ -301,4 +366,4 @@ status_t ReleaseCallbackId::readFromParcel(const Parcel* input) { 


const ReleaseCallbackId ReleaseCallbackId::INVALID_ID = ReleaseCallbackId(0, 0);



}; // namespace android::gui
 
}; // namespace android

libs/gui/LayerState.cpp

+0 −1
Original line number Diff line number Diff line
@@ -51,7 +51,6 @@ 


namespace android {



using gui::CallbackId;

using gui::FocusRequest;

using gui::WindowInfoHandle;

libs/gui/SurfaceComposerClient.cpp

+9 −24
Original line number Diff line number Diff line
@@ -314,8 +314,7 @@ void TransactionCompletedListener::addSurfaceControlToCallbacks( 
    }

}



binder::Status TransactionCompletedListener::onTransactionCompleted(

        const ListenerStats& listenerStats) {

void TransactionCompletedListener::onTransactionCompleted(ListenerStats listenerStats) {

    std::unordered_map<CallbackId, CallbackTranslation, CallbackIdHash> callbacksMap;

    std::multimap<int32_t, sp<JankDataListener>> jankListenersMap;

    {
@@ -455,10 +454,9 @@ binder::Status TransactionCompletedListener::onTransactionCompleted( 
            }

        }

    }

    return binder::Status::ok();

}



binder::Status TransactionCompletedListener::onTransactionQueueStalled(const std::string& reason) {

void TransactionCompletedListener::onTransactionQueueStalled(const String8& reason) {

    std::unordered_map<void*, std::function<void(const std::string&)>> callbackCopy;

    {

        std::scoped_lock<std::mutex> lock(mMutex);
@@ -467,7 +465,6 @@ binder::Status TransactionCompletedListener::onTransactionQueueStalled(const std 
    for (auto const& it : callbackCopy) {

        it.second(reason.c_str());

    }

    return binder::Status::ok();

}



void TransactionCompletedListener::addQueueStallListener(
@@ -481,12 +478,9 @@ void TransactionCompletedListener::removeQueueStallListener(void* id) { 
    mQueueStallListeners.erase(id);

}



binder::Status TransactionCompletedListener::onReleaseBuffer(

        const ReleaseCallbackId& callbackId,

        const std::optional<os::ParcelFileDescriptor>& releaseFenceFd,

        int32_t currentMaxAcquiredBufferCount) {

    sp<Fence> releaseFence(releaseFenceFd ? new Fence(::dup(releaseFenceFd->get()))

                                          : Fence::NO_FENCE);

void TransactionCompletedListener::onReleaseBuffer(ReleaseCallbackId callbackId,

                                                   sp<Fence> releaseFence,

                                                   uint32_t currentMaxAcquiredBufferCount) {

    ReleaseBufferCallback callback;

    {

        std::scoped_lock<std::mutex> lock(mMutex);
@@ -495,14 +489,13 @@ binder::Status TransactionCompletedListener::onReleaseBuffer( 
    if (!callback) {

        ALOGE("Could not call release buffer callback, buffer not found %s",

              callbackId.to_string().c_str());

        return binder::Status::fromExceptionCode(binder::Status::EX_ILLEGAL_ARGUMENT);

        return;

    }

    std::optional<uint32_t> optionalMaxAcquiredBufferCount =

            static_cast<uint32_t>(currentMaxAcquiredBufferCount) == UINT_MAX

            currentMaxAcquiredBufferCount == UINT_MAX

            ? std::nullopt

            : std::make_optional<uint32_t>(currentMaxAcquiredBufferCount);

    callback(callbackId, releaseFence, optionalMaxAcquiredBufferCount);

    return binder::Status::ok();

}



ReleaseBufferCallback TransactionCompletedListener::popReleaseBufferCallbackLocked(
@@ -832,11 +825,7 @@ void SurfaceComposerClient::Transaction::releaseBufferIfOverwriting(const layer_ 
                ->mReleaseCallbackThread

                .addReleaseCallback(state.bufferData->generateReleaseCallbackId(), fence);

    } else {

        std::optional<os::ParcelFileDescriptor> fenceFd;

        if (fence != Fence::NO_FENCE) {

            fenceFd = os::ParcelFileDescriptor(base::unique_fd(::dup(fence->get())));

        }

        listener->onReleaseBuffer(state.bufferData->generateReleaseCallbackId(), fenceFd, UINT_MAX);

        listener->onReleaseBuffer(state.bufferData->generateReleaseCallbackId(), fence, UINT_MAX);

    }

}
@@ -2857,11 +2846,7 @@ void ReleaseCallbackThread::threadMain() { 


        while (!callbackInfos.empty()) {

            auto [callbackId, releaseFence] = callbackInfos.front();

            std::optional<os::ParcelFileDescriptor> fenceFd;

            if (releaseFence != Fence::NO_FENCE) {

                fenceFd = os::ParcelFileDescriptor(base::unique_fd(::dup(releaseFence->get())));

            }

            listener->onReleaseBuffer(callbackId, fenceFd, UINT_MAX);

            listener->onReleaseBuffer(callbackId, std::move(releaseFence), UINT_MAX);

            callbackInfos.pop();

        }