1 /* 2 * Copyright (C) 2007 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 // tag as surfaceflinger 18 #define LOG_TAG "SurfaceFlinger" 19 20 #include <stdint.h> 21 #include <sys/types.h> 22 23 #include <binder/Parcel.h> 24 #include <binder/IPCThreadState.h> 25 #include <binder/IServiceManager.h> 26 27 #include <gui/IDisplayEventConnection.h> 28 #include <gui/IGraphicBufferProducer.h> 29 #include <gui/ISurfaceComposer.h> 30 #include <gui/ISurfaceComposerClient.h> 31 #include <gui/LayerDebugInfo.h> 32 #include <gui/LayerState.h> 33 34 #include <system/graphics.h> 35 36 #include <ui/DisplayInfo.h> 37 #include <ui/DisplayStatInfo.h> 38 #include <ui/HdrCapabilities.h> 39 40 #include <utils/Log.h> 41 42 // --------------------------------------------------------------------------- 43 44 namespace android { 45 46 using ui::ColorMode; 47 48 class BpSurfaceComposer : public BpInterface<ISurfaceComposer> 49 { 50 public: 51 explicit BpSurfaceComposer(const sp<IBinder>& impl) 52 : BpInterface<ISurfaceComposer>(impl) 53 { 54 } 55 56 virtual ~BpSurfaceComposer(); 57 58 virtual sp<ISurfaceComposerClient> createConnection() 59 { 60 Parcel data, reply; 61 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 62 remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply); 63 return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder()); 64 } 65 66 virtual sp<ISurfaceComposerClient> createScopedConnection( 67 const sp<IGraphicBufferProducer>& parent) 68 { 69 Parcel data, reply; 70 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 71 data.writeStrongBinder(IInterface::asBinder(parent)); 72 remote()->transact(BnSurfaceComposer::CREATE_SCOPED_CONNECTION, data, &reply); 73 return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder()); 74 } 75 76 virtual void setTransactionState( 77 const Vector<ComposerState>& state, 78 const Vector<DisplayState>& displays, 79 uint32_t flags) 80 { 81 Parcel data, reply; 82 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 83 84 data.writeUint32(static_cast<uint32_t>(state.size())); 85 for (const auto& s : state) { 86 s.write(data); 87 } 88 89 data.writeUint32(static_cast<uint32_t>(displays.size())); 90 for (const auto& d : displays) { 91 d.write(data); 92 } 93 94 data.writeUint32(flags); 95 remote()->transact(BnSurfaceComposer::SET_TRANSACTION_STATE, data, &reply); 96 } 97 98 virtual void bootFinished() 99 { 100 Parcel data, reply; 101 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 102 remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply); 103 } 104 105 virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer, 106 Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight, 107 int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform, 108 ISurfaceComposer::Rotation rotation) { 109 Parcel data, reply; 110 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 111 data.writeStrongBinder(display); 112 data.write(sourceCrop); 113 data.writeUint32(reqWidth); 114 data.writeUint32(reqHeight); 115 data.writeInt32(minLayerZ); 116 data.writeInt32(maxLayerZ); 117 data.writeInt32(static_cast<int32_t>(useIdentityTransform)); 118 data.writeInt32(static_cast<int32_t>(rotation)); 119 status_t err = remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply); 120 121 if (err != NO_ERROR) { 122 return err; 123 } 124 125 err = reply.readInt32(); 126 if (err != NO_ERROR) { 127 return err; 128 } 129 130 *outBuffer = new GraphicBuffer(); 131 reply.read(**outBuffer); 132 return err; 133 } 134 135 virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder, 136 sp<GraphicBuffer>* outBuffer, const Rect& sourceCrop, 137 float frameScale, bool childrenOnly) { 138 Parcel data, reply; 139 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 140 data.writeStrongBinder(layerHandleBinder); 141 data.write(sourceCrop); 142 data.writeFloat(frameScale); 143 data.writeBool(childrenOnly); 144 status_t err = remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply); 145 146 if (err != NO_ERROR) { 147 return err; 148 } 149 150 err = reply.readInt32(); 151 if (err != NO_ERROR) { 152 return err; 153 } 154 155 *outBuffer = new GraphicBuffer(); 156 reply.read(**outBuffer); 157 158 return err; 159 } 160 161 virtual bool authenticateSurfaceTexture( 162 const sp<IGraphicBufferProducer>& bufferProducer) const 163 { 164 Parcel data, reply; 165 int err = NO_ERROR; 166 err = data.writeInterfaceToken( 167 ISurfaceComposer::getInterfaceDescriptor()); 168 if (err != NO_ERROR) { 169 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing " 170 "interface descriptor: %s (%d)", strerror(-err), -err); 171 return false; 172 } 173 err = data.writeStrongBinder(IInterface::asBinder(bufferProducer)); 174 if (err != NO_ERROR) { 175 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error writing " 176 "strong binder to parcel: %s (%d)", strerror(-err), -err); 177 return false; 178 } 179 err = remote()->transact(BnSurfaceComposer::AUTHENTICATE_SURFACE, data, 180 &reply); 181 if (err != NO_ERROR) { 182 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error " 183 "performing transaction: %s (%d)", strerror(-err), -err); 184 return false; 185 } 186 int32_t result = 0; 187 err = reply.readInt32(&result); 188 if (err != NO_ERROR) { 189 ALOGE("ISurfaceComposer::authenticateSurfaceTexture: error " 190 "retrieving result: %s (%d)", strerror(-err), -err); 191 return false; 192 } 193 return result != 0; 194 } 195 196 virtual status_t getSupportedFrameTimestamps( 197 std::vector<FrameEvent>* outSupported) const { 198 if (!outSupported) { 199 return UNEXPECTED_NULL; 200 } 201 outSupported->clear(); 202 203 Parcel data, reply; 204 205 status_t err = data.writeInterfaceToken( 206 ISurfaceComposer::getInterfaceDescriptor()); 207 if (err != NO_ERROR) { 208 return err; 209 } 210 211 err = remote()->transact( 212 BnSurfaceComposer::GET_SUPPORTED_FRAME_TIMESTAMPS, 213 data, &reply); 214 if (err != NO_ERROR) { 215 return err; 216 } 217 218 int32_t result = 0; 219 err = reply.readInt32(&result); 220 if (err != NO_ERROR) { 221 return err; 222 } 223 if (result != NO_ERROR) { 224 return result; 225 } 226 227 std::vector<int32_t> supported; 228 err = reply.readInt32Vector(&supported); 229 if (err != NO_ERROR) { 230 return err; 231 } 232 233 outSupported->reserve(supported.size()); 234 for (int32_t s : supported) { 235 outSupported->push_back(static_cast<FrameEvent>(s)); 236 } 237 return NO_ERROR; 238 } 239 240 virtual sp<IDisplayEventConnection> createDisplayEventConnection(VsyncSource vsyncSource) 241 { 242 Parcel data, reply; 243 sp<IDisplayEventConnection> result; 244 int err = data.writeInterfaceToken( 245 ISurfaceComposer::getInterfaceDescriptor()); 246 if (err != NO_ERROR) { 247 return result; 248 } 249 data.writeInt32(static_cast<int32_t>(vsyncSource)); 250 err = remote()->transact( 251 BnSurfaceComposer::CREATE_DISPLAY_EVENT_CONNECTION, 252 data, &reply); 253 if (err != NO_ERROR) { 254 ALOGE("ISurfaceComposer::createDisplayEventConnection: error performing " 255 "transaction: %s (%d)", strerror(-err), -err); 256 return result; 257 } 258 result = interface_cast<IDisplayEventConnection>(reply.readStrongBinder()); 259 return result; 260 } 261 262 virtual sp<IBinder> createDisplay(const String8& displayName, bool secure) 263 { 264 Parcel data, reply; 265 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 266 data.writeString8(displayName); 267 data.writeInt32(secure ? 1 : 0); 268 remote()->transact(BnSurfaceComposer::CREATE_DISPLAY, data, &reply); 269 return reply.readStrongBinder(); 270 } 271 272 virtual void destroyDisplay(const sp<IBinder>& display) 273 { 274 Parcel data, reply; 275 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 276 data.writeStrongBinder(display); 277 remote()->transact(BnSurfaceComposer::DESTROY_DISPLAY, data, &reply); 278 } 279 280 virtual sp<IBinder> getBuiltInDisplay(int32_t id) 281 { 282 Parcel data, reply; 283 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 284 data.writeInt32(id); 285 remote()->transact(BnSurfaceComposer::GET_BUILT_IN_DISPLAY, data, &reply); 286 return reply.readStrongBinder(); 287 } 288 289 virtual void setPowerMode(const sp<IBinder>& display, int mode) 290 { 291 Parcel data, reply; 292 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 293 data.writeStrongBinder(display); 294 data.writeInt32(mode); 295 remote()->transact(BnSurfaceComposer::SET_POWER_MODE, data, &reply); 296 } 297 298 virtual status_t getDisplayConfigs(const sp<IBinder>& display, 299 Vector<DisplayInfo>* configs) 300 { 301 Parcel data, reply; 302 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 303 data.writeStrongBinder(display); 304 remote()->transact(BnSurfaceComposer::GET_DISPLAY_CONFIGS, data, &reply); 305 status_t result = reply.readInt32(); 306 if (result == NO_ERROR) { 307 size_t numConfigs = reply.readUint32(); 308 configs->clear(); 309 configs->resize(numConfigs); 310 for (size_t c = 0; c < numConfigs; ++c) { 311 memcpy(&(configs->editItemAt(c)), 312 reply.readInplace(sizeof(DisplayInfo)), 313 sizeof(DisplayInfo)); 314 } 315 } 316 return result; 317 } 318 319 virtual status_t getDisplayStats(const sp<IBinder>& display, 320 DisplayStatInfo* stats) 321 { 322 Parcel data, reply; 323 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 324 data.writeStrongBinder(display); 325 remote()->transact(BnSurfaceComposer::GET_DISPLAY_STATS, data, &reply); 326 status_t result = reply.readInt32(); 327 if (result == NO_ERROR) { 328 memcpy(stats, 329 reply.readInplace(sizeof(DisplayStatInfo)), 330 sizeof(DisplayStatInfo)); 331 } 332 return result; 333 } 334 335 virtual int getActiveConfig(const sp<IBinder>& display) 336 { 337 Parcel data, reply; 338 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 339 data.writeStrongBinder(display); 340 remote()->transact(BnSurfaceComposer::GET_ACTIVE_CONFIG, data, &reply); 341 return reply.readInt32(); 342 } 343 344 virtual status_t setActiveConfig(const sp<IBinder>& display, int id) 345 { 346 Parcel data, reply; 347 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 348 data.writeStrongBinder(display); 349 data.writeInt32(id); 350 remote()->transact(BnSurfaceComposer::SET_ACTIVE_CONFIG, data, &reply); 351 return reply.readInt32(); 352 } 353 354 virtual status_t getDisplayColorModes(const sp<IBinder>& display, 355 Vector<ColorMode>* outColorModes) { 356 Parcel data, reply; 357 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 358 if (result != NO_ERROR) { 359 ALOGE("getDisplayColorModes failed to writeInterfaceToken: %d", result); 360 return result; 361 } 362 result = data.writeStrongBinder(display); 363 if (result != NO_ERROR) { 364 ALOGE("getDisplayColorModes failed to writeStrongBinder: %d", result); 365 return result; 366 } 367 result = remote()->transact(BnSurfaceComposer::GET_DISPLAY_COLOR_MODES, data, &reply); 368 if (result != NO_ERROR) { 369 ALOGE("getDisplayColorModes failed to transact: %d", result); 370 return result; 371 } 372 result = static_cast<status_t>(reply.readInt32()); 373 if (result == NO_ERROR) { 374 size_t numModes = reply.readUint32(); 375 outColorModes->clear(); 376 outColorModes->resize(numModes); 377 for (size_t i = 0; i < numModes; ++i) { 378 outColorModes->replaceAt(static_cast<ColorMode>(reply.readInt32()), i); 379 } 380 } 381 return result; 382 } 383 384 virtual ColorMode getActiveColorMode(const sp<IBinder>& display) { 385 Parcel data, reply; 386 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 387 if (result != NO_ERROR) { 388 ALOGE("getActiveColorMode failed to writeInterfaceToken: %d", result); 389 return static_cast<ColorMode>(result); 390 } 391 result = data.writeStrongBinder(display); 392 if (result != NO_ERROR) { 393 ALOGE("getActiveColorMode failed to writeStrongBinder: %d", result); 394 return static_cast<ColorMode>(result); 395 } 396 result = remote()->transact(BnSurfaceComposer::GET_ACTIVE_COLOR_MODE, data, &reply); 397 if (result != NO_ERROR) { 398 ALOGE("getActiveColorMode failed to transact: %d", result); 399 return static_cast<ColorMode>(result); 400 } 401 return static_cast<ColorMode>(reply.readInt32()); 402 } 403 404 virtual status_t setActiveColorMode(const sp<IBinder>& display, 405 ColorMode colorMode) { 406 Parcel data, reply; 407 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 408 if (result != NO_ERROR) { 409 ALOGE("setActiveColorMode failed to writeInterfaceToken: %d", result); 410 return result; 411 } 412 result = data.writeStrongBinder(display); 413 if (result != NO_ERROR) { 414 ALOGE("setActiveColorMode failed to writeStrongBinder: %d", result); 415 return result; 416 } 417 result = data.writeInt32(static_cast<int32_t>(colorMode)); 418 if (result != NO_ERROR) { 419 ALOGE("setActiveColorMode failed to writeInt32: %d", result); 420 return result; 421 } 422 result = remote()->transact(BnSurfaceComposer::SET_ACTIVE_COLOR_MODE, data, &reply); 423 if (result != NO_ERROR) { 424 ALOGE("setActiveColorMode failed to transact: %d", result); 425 return result; 426 } 427 return static_cast<status_t>(reply.readInt32()); 428 } 429 430 virtual status_t clearAnimationFrameStats() { 431 Parcel data, reply; 432 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 433 remote()->transact(BnSurfaceComposer::CLEAR_ANIMATION_FRAME_STATS, data, &reply); 434 return reply.readInt32(); 435 } 436 437 virtual status_t getAnimationFrameStats(FrameStats* outStats) const { 438 Parcel data, reply; 439 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 440 remote()->transact(BnSurfaceComposer::GET_ANIMATION_FRAME_STATS, data, &reply); 441 reply.read(*outStats); 442 return reply.readInt32(); 443 } 444 445 virtual status_t getHdrCapabilities(const sp<IBinder>& display, 446 HdrCapabilities* outCapabilities) const { 447 Parcel data, reply; 448 data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 449 status_t result = data.writeStrongBinder(display); 450 if (result != NO_ERROR) { 451 ALOGE("getHdrCapabilities failed to writeStrongBinder: %d", result); 452 return result; 453 } 454 result = remote()->transact(BnSurfaceComposer::GET_HDR_CAPABILITIES, 455 data, &reply); 456 if (result != NO_ERROR) { 457 ALOGE("getHdrCapabilities failed to transact: %d", result); 458 return result; 459 } 460 result = reply.readInt32(); 461 if (result == NO_ERROR) { 462 result = reply.read(*outCapabilities); 463 } 464 return result; 465 } 466 467 virtual status_t enableVSyncInjections(bool enable) { 468 Parcel data, reply; 469 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 470 if (result != NO_ERROR) { 471 ALOGE("enableVSyncInjections failed to writeInterfaceToken: %d", result); 472 return result; 473 } 474 result = data.writeBool(enable); 475 if (result != NO_ERROR) { 476 ALOGE("enableVSyncInjections failed to writeBool: %d", result); 477 return result; 478 } 479 result = remote()->transact(BnSurfaceComposer::ENABLE_VSYNC_INJECTIONS, 480 data, &reply, TF_ONE_WAY); 481 if (result != NO_ERROR) { 482 ALOGE("enableVSyncInjections failed to transact: %d", result); 483 return result; 484 } 485 return result; 486 } 487 488 virtual status_t injectVSync(nsecs_t when) { 489 Parcel data, reply; 490 status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 491 if (result != NO_ERROR) { 492 ALOGE("injectVSync failed to writeInterfaceToken: %d", result); 493 return result; 494 } 495 result = data.writeInt64(when); 496 if (result != NO_ERROR) { 497 ALOGE("injectVSync failed to writeInt64: %d", result); 498 return result; 499 } 500 result = remote()->transact(BnSurfaceComposer::INJECT_VSYNC, data, &reply, TF_ONE_WAY); 501 if (result != NO_ERROR) { 502 ALOGE("injectVSync failed to transact: %d", result); 503 return result; 504 } 505 return result; 506 } 507 508 virtual status_t getLayerDebugInfo(std::vector<LayerDebugInfo>* outLayers) const 509 { 510 if (!outLayers) { 511 return UNEXPECTED_NULL; 512 } 513 514 Parcel data, reply; 515 516 status_t err = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); 517 if (err != NO_ERROR) { 518 return err; 519 } 520 521 err = remote()->transact(BnSurfaceComposer::GET_LAYER_DEBUG_INFO, data, &reply); 522 if (err != NO_ERROR) { 523 return err; 524 } 525 526 int32_t result = 0; 527 err = reply.readInt32(&result); 528 if (err != NO_ERROR) { 529 return err; 530 } 531 if (result != NO_ERROR) { 532 return result; 533 } 534 535 outLayers->clear(); 536 return reply.readParcelableVector(outLayers); 537 } 538 }; 539 540 // Out-of-line virtual method definition to trigger vtable emission in this 541 // translation unit (see clang warning -Wweak-vtables) 542 BpSurfaceComposer::~BpSurfaceComposer() {} 543 544 IMPLEMENT_META_INTERFACE(SurfaceComposer, "android.ui.ISurfaceComposer"); 545 546 // ---------------------------------------------------------------------- 547 548 status_t BnSurfaceComposer::onTransact( 549 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) 550 { 551 switch(code) { 552 case CREATE_CONNECTION: { 553 CHECK_INTERFACE(ISurfaceComposer, data, reply); 554 sp<IBinder> b = IInterface::asBinder(createConnection()); 555 reply->writeStrongBinder(b); 556 return NO_ERROR; 557 } 558 case CREATE_SCOPED_CONNECTION: { 559 CHECK_INTERFACE(ISurfaceComposer, data, reply); 560 sp<IGraphicBufferProducer> bufferProducer = 561 interface_cast<IGraphicBufferProducer>(data.readStrongBinder()); 562 sp<IBinder> b = IInterface::asBinder(createScopedConnection(bufferProducer)); 563 reply->writeStrongBinder(b); 564 return NO_ERROR; 565 } 566 case SET_TRANSACTION_STATE: { 567 CHECK_INTERFACE(ISurfaceComposer, data, reply); 568 569 size_t count = data.readUint32(); 570 if (count > data.dataSize()) { 571 return BAD_VALUE; 572 } 573 ComposerState s; 574 Vector<ComposerState> state; 575 state.setCapacity(count); 576 for (size_t i = 0; i < count; i++) { 577 if (s.read(data) == BAD_VALUE) { 578 return BAD_VALUE; 579 } 580 state.add(s); 581 } 582 583 count = data.readUint32(); 584 if (count > data.dataSize()) { 585 return BAD_VALUE; 586 } 587 DisplayState d; 588 Vector<DisplayState> displays; 589 displays.setCapacity(count); 590 for (size_t i = 0; i < count; i++) { 591 if (d.read(data) == BAD_VALUE) { 592 return BAD_VALUE; 593 } 594 displays.add(d); 595 } 596 597 uint32_t stateFlags = data.readUint32(); 598 setTransactionState(state, displays, stateFlags); 599 return NO_ERROR; 600 } 601 case BOOT_FINISHED: { 602 CHECK_INTERFACE(ISurfaceComposer, data, reply); 603 bootFinished(); 604 return NO_ERROR; 605 } 606 case CAPTURE_SCREEN: { 607 CHECK_INTERFACE(ISurfaceComposer, data, reply); 608 sp<IBinder> display = data.readStrongBinder(); 609 sp<GraphicBuffer> outBuffer; 610 Rect sourceCrop(Rect::EMPTY_RECT); 611 data.read(sourceCrop); 612 uint32_t reqWidth = data.readUint32(); 613 uint32_t reqHeight = data.readUint32(); 614 int32_t minLayerZ = data.readInt32(); 615 int32_t maxLayerZ = data.readInt32(); 616 bool useIdentityTransform = static_cast<bool>(data.readInt32()); 617 int32_t rotation = data.readInt32(); 618 619 status_t res = captureScreen(display, &outBuffer, sourceCrop, reqWidth, reqHeight, 620 minLayerZ, maxLayerZ, useIdentityTransform, 621 static_cast<ISurfaceComposer::Rotation>(rotation)); 622 reply->writeInt32(res); 623 if (res == NO_ERROR) { 624 reply->write(*outBuffer); 625 } 626 return NO_ERROR; 627 } 628 case CAPTURE_LAYERS: { 629 CHECK_INTERFACE(ISurfaceComposer, data, reply); 630 sp<IBinder> layerHandleBinder = data.readStrongBinder(); 631 sp<GraphicBuffer> outBuffer; 632 Rect sourceCrop(Rect::EMPTY_RECT); 633 data.read(sourceCrop); 634 float frameScale = data.readFloat(); 635 bool childrenOnly = data.readBool(); 636 637 status_t res = captureLayers(layerHandleBinder, &outBuffer, sourceCrop, frameScale, 638 childrenOnly); 639 reply->writeInt32(res); 640 if (res == NO_ERROR) { 641 reply->write(*outBuffer); 642 } 643 return NO_ERROR; 644 } 645 case AUTHENTICATE_SURFACE: { 646 CHECK_INTERFACE(ISurfaceComposer, data, reply); 647 sp<IGraphicBufferProducer> bufferProducer = 648 interface_cast<IGraphicBufferProducer>(data.readStrongBinder()); 649 int32_t result = authenticateSurfaceTexture(bufferProducer) ? 1 : 0; 650 reply->writeInt32(result); 651 return NO_ERROR; 652 } 653 case GET_SUPPORTED_FRAME_TIMESTAMPS: { 654 CHECK_INTERFACE(ISurfaceComposer, data, reply); 655 std::vector<FrameEvent> supportedTimestamps; 656 status_t result = getSupportedFrameTimestamps(&supportedTimestamps); 657 status_t err = reply->writeInt32(result); 658 if (err != NO_ERROR) { 659 return err; 660 } 661 if (result != NO_ERROR) { 662 return result; 663 } 664 665 std::vector<int32_t> supported; 666 supported.reserve(supportedTimestamps.size()); 667 for (FrameEvent s : supportedTimestamps) { 668 supported.push_back(static_cast<int32_t>(s)); 669 } 670 return reply->writeInt32Vector(supported); 671 } 672 case CREATE_DISPLAY_EVENT_CONNECTION: { 673 CHECK_INTERFACE(ISurfaceComposer, data, reply); 674 sp<IDisplayEventConnection> connection(createDisplayEventConnection( 675 static_cast<ISurfaceComposer::VsyncSource>(data.readInt32()))); 676 reply->writeStrongBinder(IInterface::asBinder(connection)); 677 return NO_ERROR; 678 } 679 case CREATE_DISPLAY: { 680 CHECK_INTERFACE(ISurfaceComposer, data, reply); 681 String8 displayName = data.readString8(); 682 bool secure = bool(data.readInt32()); 683 sp<IBinder> display(createDisplay(displayName, secure)); 684 reply->writeStrongBinder(display); 685 return NO_ERROR; 686 } 687 case DESTROY_DISPLAY: { 688 CHECK_INTERFACE(ISurfaceComposer, data, reply); 689 sp<IBinder> display = data.readStrongBinder(); 690 destroyDisplay(display); 691 return NO_ERROR; 692 } 693 case GET_BUILT_IN_DISPLAY: { 694 CHECK_INTERFACE(ISurfaceComposer, data, reply); 695 int32_t id = data.readInt32(); 696 sp<IBinder> display(getBuiltInDisplay(id)); 697 reply->writeStrongBinder(display); 698 return NO_ERROR; 699 } 700 case GET_DISPLAY_CONFIGS: { 701 CHECK_INTERFACE(ISurfaceComposer, data, reply); 702 Vector<DisplayInfo> configs; 703 sp<IBinder> display = data.readStrongBinder(); 704 status_t result = getDisplayConfigs(display, &configs); 705 reply->writeInt32(result); 706 if (result == NO_ERROR) { 707 reply->writeUint32(static_cast<uint32_t>(configs.size())); 708 for (size_t c = 0; c < configs.size(); ++c) { 709 memcpy(reply->writeInplace(sizeof(DisplayInfo)), 710 &configs[c], sizeof(DisplayInfo)); 711 } 712 } 713 return NO_ERROR; 714 } 715 case GET_DISPLAY_STATS: { 716 CHECK_INTERFACE(ISurfaceComposer, data, reply); 717 DisplayStatInfo stats; 718 sp<IBinder> display = data.readStrongBinder(); 719 status_t result = getDisplayStats(display, &stats); 720 reply->writeInt32(result); 721 if (result == NO_ERROR) { 722 memcpy(reply->writeInplace(sizeof(DisplayStatInfo)), 723 &stats, sizeof(DisplayStatInfo)); 724 } 725 return NO_ERROR; 726 } 727 case GET_ACTIVE_CONFIG: { 728 CHECK_INTERFACE(ISurfaceComposer, data, reply); 729 sp<IBinder> display = data.readStrongBinder(); 730 int id = getActiveConfig(display); 731 reply->writeInt32(id); 732 return NO_ERROR; 733 } 734 case SET_ACTIVE_CONFIG: { 735 CHECK_INTERFACE(ISurfaceComposer, data, reply); 736 sp<IBinder> display = data.readStrongBinder(); 737 int id = data.readInt32(); 738 status_t result = setActiveConfig(display, id); 739 reply->writeInt32(result); 740 return NO_ERROR; 741 } 742 case GET_DISPLAY_COLOR_MODES: { 743 CHECK_INTERFACE(ISurfaceComposer, data, reply); 744 Vector<ColorMode> colorModes; 745 sp<IBinder> display = nullptr; 746 status_t result = data.readStrongBinder(&display); 747 if (result != NO_ERROR) { 748 ALOGE("getDisplayColorModes failed to readStrongBinder: %d", result); 749 return result; 750 } 751 result = getDisplayColorModes(display, &colorModes); 752 reply->writeInt32(result); 753 if (result == NO_ERROR) { 754 reply->writeUint32(static_cast<uint32_t>(colorModes.size())); 755 for (size_t i = 0; i < colorModes.size(); ++i) { 756 reply->writeInt32(static_cast<int32_t>(colorModes[i])); 757 } 758 } 759 return NO_ERROR; 760 } 761 case GET_ACTIVE_COLOR_MODE: { 762 CHECK_INTERFACE(ISurfaceComposer, data, reply); 763 sp<IBinder> display = nullptr; 764 status_t result = data.readStrongBinder(&display); 765 if (result != NO_ERROR) { 766 ALOGE("getActiveColorMode failed to readStrongBinder: %d", result); 767 return result; 768 } 769 ColorMode colorMode = getActiveColorMode(display); 770 result = reply->writeInt32(static_cast<int32_t>(colorMode)); 771 return result; 772 } 773 case SET_ACTIVE_COLOR_MODE: { 774 CHECK_INTERFACE(ISurfaceComposer, data, reply); 775 sp<IBinder> display = nullptr; 776 status_t result = data.readStrongBinder(&display); 777 if (result != NO_ERROR) { 778 ALOGE("getActiveColorMode failed to readStrongBinder: %d", result); 779 return result; 780 } 781 int32_t colorModeInt = 0; 782 result = data.readInt32(&colorModeInt); 783 if (result != NO_ERROR) { 784 ALOGE("setActiveColorMode failed to readInt32: %d", result); 785 return result; 786 } 787 result = setActiveColorMode(display, 788 static_cast<ColorMode>(colorModeInt)); 789 result = reply->writeInt32(result); 790 return result; 791 } 792 case CLEAR_ANIMATION_FRAME_STATS: { 793 CHECK_INTERFACE(ISurfaceComposer, data, reply); 794 status_t result = clearAnimationFrameStats(); 795 reply->writeInt32(result); 796 return NO_ERROR; 797 } 798 case GET_ANIMATION_FRAME_STATS: { 799 CHECK_INTERFACE(ISurfaceComposer, data, reply); 800 FrameStats stats; 801 status_t result = getAnimationFrameStats(&stats); 802 reply->write(stats); 803 reply->writeInt32(result); 804 return NO_ERROR; 805 } 806 case SET_POWER_MODE: { 807 CHECK_INTERFACE(ISurfaceComposer, data, reply); 808 sp<IBinder> display = data.readStrongBinder(); 809 int32_t mode = data.readInt32(); 810 setPowerMode(display, mode); 811 return NO_ERROR; 812 } 813 case GET_HDR_CAPABILITIES: { 814 CHECK_INTERFACE(ISurfaceComposer, data, reply); 815 sp<IBinder> display = nullptr; 816 status_t result = data.readStrongBinder(&display); 817 if (result != NO_ERROR) { 818 ALOGE("getHdrCapabilities failed to readStrongBinder: %d", 819 result); 820 return result; 821 } 822 HdrCapabilities capabilities; 823 result = getHdrCapabilities(display, &capabilities); 824 reply->writeInt32(result); 825 if (result == NO_ERROR) { 826 reply->write(capabilities); 827 } 828 return NO_ERROR; 829 } 830 case ENABLE_VSYNC_INJECTIONS: { 831 CHECK_INTERFACE(ISurfaceComposer, data, reply); 832 bool enable = false; 833 status_t result = data.readBool(&enable); 834 if (result != NO_ERROR) { 835 ALOGE("enableVSyncInjections failed to readBool: %d", result); 836 return result; 837 } 838 return enableVSyncInjections(enable); 839 } 840 case INJECT_VSYNC: { 841 CHECK_INTERFACE(ISurfaceComposer, data, reply); 842 int64_t when = 0; 843 status_t result = data.readInt64(&when); 844 if (result != NO_ERROR) { 845 ALOGE("enableVSyncInjections failed to readInt64: %d", result); 846 return result; 847 } 848 return injectVSync(when); 849 } 850 case GET_LAYER_DEBUG_INFO: { 851 CHECK_INTERFACE(ISurfaceComposer, data, reply); 852 std::vector<LayerDebugInfo> outLayers; 853 status_t result = getLayerDebugInfo(&outLayers); 854 reply->writeInt32(result); 855 if (result == NO_ERROR) 856 { 857 result = reply->writeParcelableVector(outLayers); 858 } 859 return result; 860 } 861 default: { 862 return BBinder::onTransact(code, data, reply, flags); 863 } 864 } 865 } 866 867 // ---------------------------------------------------------------------------- 868 869 }; 870
