1 /* 2 * Copyright 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <condition_variable> 20 #include <deque> 21 #include <mutex> 22 #include <thread> 23 #include <unordered_map> 24 #include <unordered_set> 25 26 #include <android-base/thread_annotations.h> 27 28 #include <binder/IBinder.h> 29 #include <gui/ITransactionCompletedListener.h> 30 #include <ui/Fence.h> 31 32 namespace android { 33 34 class CallbackHandle : public RefBase { 35 public: 36 CallbackHandle(const sp<IBinder>& transactionListener, const std::vector<CallbackId>& ids, 37 const sp<IBinder>& sc); 38 39 sp<IBinder> listener; 40 std::vector<CallbackId> callbackIds; 41 wp<IBinder> surfaceControl; 42 43 bool releasePreviousBuffer = false; 44 sp<Fence> previousReleaseFence; 45 nsecs_t acquireTime = -1; 46 nsecs_t latchTime = -1; 47 uint32_t transformHint = 0; 48 uint32_t currentMaxAcquiredBufferCount = 0; 49 std::shared_ptr<FenceTime> gpuCompositionDoneFence{FenceTime::NO_FENCE}; 50 CompositorTiming compositorTiming; 51 nsecs_t refreshStartTime = 0; 52 nsecs_t dequeueReadyTime = 0; 53 uint64_t frameNumber = 0; 54 ReleaseCallbackId previousReleaseCallbackId = ReleaseCallbackId::INVALID_ID; 55 }; 56 57 class TransactionCallbackInvoker { 58 public: 59 ~TransactionCallbackInvoker(); 60 61 // Adds listener and callbackIds in case there are no SurfaceControls that are supposed 62 // to be included in the callback. This functions should be call before attempting to register 63 // any callback handles. 64 status_t startRegistration(const ListenerCallbacks& listenerCallbacks); 65 // Ends the registration. After this is called, no more CallbackHandles will be registered. 66 // It is safe to send a callback if the Transaction doesn't have any Pending callback handles. 67 status_t endRegistration(const ListenerCallbacks& listenerCallbacks); 68 69 // Informs the TransactionCallbackInvoker that there is a Transaction with a CallbackHandle 70 // that needs to be latched and presented this frame. This function should be called once the 71 // layer has received the CallbackHandle so the TransactionCallbackInvoker knows not to send 72 // a callback for that Listener/Transaction pair until that CallbackHandle has been latched and 73 // presented. 74 status_t registerPendingCallbackHandle(const sp<CallbackHandle>& handle); 75 // Notifies the TransactionCallbackInvoker that a pending CallbackHandle has been presented. 76 status_t finalizePendingCallbackHandles(const std::deque<sp<CallbackHandle>>& handles, 77 const std::vector<JankData>& jankData); 78 status_t finalizeOnCommitCallbackHandles(const std::deque<sp<CallbackHandle>>& handles, 79 std::deque<sp<CallbackHandle>>& outRemainingHandles); 80 81 // Adds the Transaction CallbackHandle from a layer that does not need to be relatched and 82 // presented this frame. 83 status_t registerUnpresentedCallbackHandle(const sp<CallbackHandle>& handle); 84 85 void addPresentFence(const sp<Fence>& presentFence); 86 87 void sendCallbacks(); 88 89 private: 90 91 bool isRegisteringTransaction(const sp<IBinder>& transactionListener, 92 const std::vector<CallbackId>& callbackIds) REQUIRES(mMutex); 93 94 status_t findTransactionStats(const sp<IBinder>& listener, 95 const std::vector<CallbackId>& callbackIds, 96 TransactionStats** outTransactionStats) REQUIRES(mMutex); 97 98 status_t addCallbackHandle(const sp<CallbackHandle>& handle, 99 const std::vector<JankData>& jankData) REQUIRES(mMutex); 100 101 status_t finalizeCallbackHandle(const sp<CallbackHandle>& handle, 102 const std::vector<JankData>& jankData) REQUIRES(mMutex); 103 104 class CallbackDeathRecipient : public IBinder::DeathRecipient { 105 public: 106 // This function is a no-op. isBinderAlive needs a linked DeathRecipient to work. 107 // Death recipients needs a binderDied function. 108 // 109 // (isBinderAlive checks if BpBinder's mAlive is 0. mAlive is only set to 0 in sendObituary. 110 // sendObituary is only called if linkToDeath was called with a DeathRecipient.) binderDied(const wp<IBinder> &)111 void binderDied(const wp<IBinder>& /*who*/) override {} 112 }; 113 sp<CallbackDeathRecipient> mDeathRecipient = 114 new CallbackDeathRecipient(); 115 116 std::mutex mMutex; 117 std::condition_variable_any mConditionVariable; 118 119 std::unordered_set<ListenerCallbacks, ListenerCallbacksHash> mRegisteringTransactions 120 GUARDED_BY(mMutex); 121 122 std::unordered_map< 123 sp<IBinder>, 124 std::unordered_map<std::vector<CallbackId>, uint32_t /*count*/, CallbackIdsHash>, 125 IListenerHash> 126 mPendingTransactions GUARDED_BY(mMutex); 127 128 std::unordered_map<sp<IBinder>, std::deque<TransactionStats>, IListenerHash> 129 mCompletedTransactions GUARDED_BY(mMutex); 130 131 sp<Fence> mPresentFence GUARDED_BY(mMutex); 132 }; 133 134 } // namespace android 135