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 #include <gui/BufferHubConsumer.h> 18 19 namespace android { 20 21 using namespace dvr; 22 23 /* static */ 24 sp<BufferHubConsumer> BufferHubConsumer::Create(const std::shared_ptr<ConsumerQueue>& queue) { 25 sp<BufferHubConsumer> consumer = new BufferHubConsumer; 26 consumer->mQueue = queue; 27 return consumer; 28 } 29 30 /* static */ sp<BufferHubConsumer> BufferHubConsumer::Create(ConsumerQueueParcelable parcelable) { 31 if (!parcelable.IsValid()) { 32 ALOGE("BufferHubConsumer::Create: Invalid consumer parcelable."); 33 return nullptr; 34 } 35 36 sp<BufferHubConsumer> consumer = new BufferHubConsumer; 37 consumer->mQueue = ConsumerQueue::Import(parcelable.TakeChannelHandle()); 38 return consumer; 39 } 40 41 status_t BufferHubConsumer::acquireBuffer(BufferItem* /*buffer*/, nsecs_t /*presentWhen*/, 42 uint64_t /*maxFrameNumber*/) { 43 ALOGE("BufferHubConsumer::acquireBuffer: not implemented."); 44 return INVALID_OPERATION; 45 } 46 47 status_t BufferHubConsumer::detachBuffer(int /*slot*/) { 48 ALOGE("BufferHubConsumer::detachBuffer: not implemented."); 49 return INVALID_OPERATION; 50 } 51 52 status_t BufferHubConsumer::attachBuffer(int* /*outSlot*/, const sp<GraphicBuffer>& /*buffer*/) { 53 ALOGE("BufferHubConsumer::attachBuffer: not implemented."); 54 return INVALID_OPERATION; 55 } 56 57 status_t BufferHubConsumer::releaseBuffer(int /*buf*/, uint64_t /*frameNumber*/, 58 EGLDisplay /*display*/, EGLSyncKHR /*fence*/, 59 const sp<Fence>& /*releaseFence*/) { 60 ALOGE("BufferHubConsumer::releaseBuffer: not implemented."); 61 return INVALID_OPERATION; 62 } 63 64 status_t BufferHubConsumer::consumerConnect(const sp<IConsumerListener>& /*consumer*/, 65 bool /*controlledByApp*/) { 66 ALOGE("BufferHubConsumer::consumerConnect: not implemented."); 67 68 // TODO(b/73267953): Make BufferHub honor producer and consumer connection. Returns NO_ERROR to 69 // make IGraphicBufferConsumer_test happy. 70 return NO_ERROR; 71 } 72 73 status_t BufferHubConsumer::consumerDisconnect() { 74 ALOGE("BufferHubConsumer::consumerDisconnect: not implemented."); 75 76 // TODO(b/73267953): Make BufferHub honor producer and consumer connection. Returns NO_ERROR to 77 // make IGraphicBufferConsumer_test happy. 78 return NO_ERROR; 79 } 80 81 status_t BufferHubConsumer::getReleasedBuffers(uint64_t* /*slotMask*/) { 82 ALOGE("BufferHubConsumer::getReleasedBuffers: not implemented."); 83 return INVALID_OPERATION; 84 } 85 86 status_t BufferHubConsumer::setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) { 87 ALOGE("BufferHubConsumer::setDefaultBufferSize: not implemented."); 88 return INVALID_OPERATION; 89 } 90 91 status_t BufferHubConsumer::setMaxBufferCount(int /*bufferCount*/) { 92 ALOGE("BufferHubConsumer::setMaxBufferCount: not implemented."); 93 return INVALID_OPERATION; 94 } 95 96 status_t BufferHubConsumer::setMaxAcquiredBufferCount(int /*maxAcquiredBuffers*/) { 97 ALOGE("BufferHubConsumer::setMaxAcquiredBufferCount: not implemented."); 98 99 // TODO(b/73267953): Make BufferHub honor producer and consumer connection. Returns NO_ERROR to 100 // make IGraphicBufferConsumer_test happy. 101 return NO_ERROR; 102 } 103 104 status_t BufferHubConsumer::setConsumerName(const String8& /*name*/) { 105 ALOGE("BufferHubConsumer::setConsumerName: not implemented."); 106 return INVALID_OPERATION; 107 } 108 109 status_t BufferHubConsumer::setDefaultBufferFormat(PixelFormat /*defaultFormat*/) { 110 ALOGE("BufferHubConsumer::setDefaultBufferFormat: not implemented."); 111 return INVALID_OPERATION; 112 } 113 114 status_t BufferHubConsumer::setDefaultBufferDataSpace(android_dataspace /*defaultDataSpace*/) { 115 ALOGE("BufferHubConsumer::setDefaultBufferDataSpace: not implemented."); 116 return INVALID_OPERATION; 117 } 118 119 status_t BufferHubConsumer::setConsumerUsageBits(uint64_t /*usage*/) { 120 ALOGE("BufferHubConsumer::setConsumerUsageBits: not implemented."); 121 return INVALID_OPERATION; 122 } 123 124 status_t BufferHubConsumer::setConsumerIsProtected(bool /*isProtected*/) { 125 ALOGE("BufferHubConsumer::setConsumerIsProtected: not implemented."); 126 return INVALID_OPERATION; 127 } 128 129 status_t BufferHubConsumer::setTransformHint(uint32_t /*hint*/) { 130 ALOGE("BufferHubConsumer::setTransformHint: not implemented."); 131 return INVALID_OPERATION; 132 } 133 134 status_t BufferHubConsumer::getSidebandStream(sp<NativeHandle>* /*outStream*/) const { 135 ALOGE("BufferHubConsumer::getSidebandStream: not implemented."); 136 return INVALID_OPERATION; 137 } 138 139 status_t BufferHubConsumer::getOccupancyHistory( 140 bool /*forceFlush*/, std::vector<OccupancyTracker::Segment>* /*outHistory*/) { 141 ALOGE("BufferHubConsumer::getOccupancyHistory: not implemented."); 142 return INVALID_OPERATION; 143 } 144 145 status_t BufferHubConsumer::discardFreeBuffers() { 146 ALOGE("BufferHubConsumer::discardFreeBuffers: not implemented."); 147 return INVALID_OPERATION; 148 } 149 150 status_t BufferHubConsumer::dumpState(const String8& /*prefix*/, String8* /*outResult*/) const { 151 ALOGE("BufferHubConsumer::dumpState: not implemented."); 152 return INVALID_OPERATION; 153 } 154 155 IBinder* BufferHubConsumer::onAsBinder() { 156 ALOGE("BufferHubConsumer::onAsBinder: BufferHubConsumer should never be used as an Binder " 157 "object."); 158 return nullptr; 159 } 160 161 } // namespace android 162
