From 88a096aa96ddb8a2917ff8bd5dc337ed7b9d06fb Mon Sep 17 00:00:00 2001 From: Crepieux Pierre Date: Wed, 4 Sep 2019 16:33:42 +0200 Subject: [PATCH 1/2] let's start from android 9 to provide android 10 support --- jni/minicap-shared/aosp/src/minicap_29.cpp | 386 +++++++++++++++++++++ 1 file changed, 386 insertions(+) create mode 100644 jni/minicap-shared/aosp/src/minicap_29.cpp diff --git a/jni/minicap-shared/aosp/src/minicap_29.cpp b/jni/minicap-shared/aosp/src/minicap_29.cpp new file mode 100644 index 00000000..c5a04d39 --- /dev/null +++ b/jni/minicap-shared/aosp/src/minicap_29.cpp @@ -0,0 +1,386 @@ +#include "Minicap.hpp" + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "mcdebug.h" + +static const char* +error_name(int32_t err) { + switch (err) { + case android::NO_ERROR: // also android::OK + return "NO_ERROR"; + case android::UNKNOWN_ERROR: + return "UNKNOWN_ERROR"; + case android::NO_MEMORY: + return "NO_MEMORY"; + case android::INVALID_OPERATION: + return "INVALID_OPERATION"; + case android::BAD_VALUE: + return "BAD_VALUE"; + case android::BAD_TYPE: + return "BAD_TYPE"; + case android::NAME_NOT_FOUND: + return "NAME_NOT_FOUND"; + case android::PERMISSION_DENIED: + return "PERMISSION_DENIED"; + case android::NO_INIT: + return "NO_INIT"; + case android::ALREADY_EXISTS: + return "ALREADY_EXISTS"; + case android::DEAD_OBJECT: // also android::JPARKS_BROKE_IT + return "DEAD_OBJECT"; + case android::FAILED_TRANSACTION: + return "FAILED_TRANSACTION"; + case android::BAD_INDEX: + return "BAD_INDEX"; + case android::NOT_ENOUGH_DATA: + return "NOT_ENOUGH_DATA"; + case android::WOULD_BLOCK: + return "WOULD_BLOCK"; + case android::TIMED_OUT: + return "TIMED_OUT"; + case android::UNKNOWN_TRANSACTION: + return "UNKNOWN_TRANSACTION"; + case android::FDS_NOT_ALLOWED: + return "FDS_NOT_ALLOWED"; + default: + return "UNMAPPED_ERROR"; + } +} + +class FrameProxy: public android::ConsumerBase::FrameAvailableListener { +public: + FrameProxy(Minicap::FrameAvailableListener* listener): mUserListener(listener) { + } + + virtual void + onFrameAvailable(const android::BufferItem& /* item */) { + mUserListener->onFrameAvailable(); + } + +private: + Minicap::FrameAvailableListener* mUserListener; +}; + +class MinicapImpl: public Minicap +{ +public: + MinicapImpl(int32_t displayId) + : mDisplayId(displayId), + mRealWidth(0), + mRealHeight(0), + mDesiredWidth(0), + mDesiredHeight(0), + mDesiredOrientation(0), + mHaveBuffer(false), + mHaveRunningDisplay(false) { + } + + virtual + ~MinicapImpl() { + release(); + } + + virtual int + applyConfigChanges() { + if (mHaveRunningDisplay) { + destroyVirtualDisplay(); + } + + return createVirtualDisplay(); + } + + virtual int + consumePendingFrame(Minicap::Frame* frame) { + android::status_t err; + + if ((err = mConsumer->lockNextBuffer(&mBuffer)) != android::NO_ERROR) { + if (err == -EINTR) { + return err; + } + else { + MCERROR("Unable to lock next buffer %s (%d)", error_name(err), err); + return err; + } + } + + frame->data = mBuffer.data; + frame->format = convertFormat(mBuffer.format); + frame->width = mBuffer.width; + frame->height = mBuffer.height; + frame->stride = mBuffer.stride; + frame->bpp = android::bytesPerPixel(mBuffer.format); + frame->size = mBuffer.stride * mBuffer.height * frame->bpp; + + mHaveBuffer = true; + + return 0; + } + + virtual Minicap::CaptureMethod + getCaptureMethod() { + return METHOD_VIRTUAL_DISPLAY; + } + + virtual int32_t + getDisplayId() { + return mDisplayId; + } + + virtual void + release() { + destroyVirtualDisplay(); + } + + virtual void + releaseConsumedFrame(Minicap::Frame* /* frame */) { + if (mHaveBuffer) { + mConsumer->unlockBuffer(mBuffer); + mHaveBuffer = false; + } + } + + virtual int + setDesiredInfo(const Minicap::DisplayInfo& info) { + mDesiredWidth = info.width; + mDesiredHeight = info.height; + mDesiredOrientation = info.orientation; + return 0; + } + + virtual void + setFrameAvailableListener(Minicap::FrameAvailableListener* listener) { + mUserFrameAvailableListener = listener; + } + + virtual int + setRealInfo(const Minicap::DisplayInfo& info) { + mRealWidth = info.width; + mRealHeight = info.height; + return 0; + } + +private: + int32_t mDisplayId; + uint32_t mRealWidth; + uint32_t mRealHeight; + uint32_t mDesiredWidth; + uint32_t mDesiredHeight; + uint8_t mDesiredOrientation; + android::sp mBufferProducer; + android::sp mBufferConsumer; + android::sp mConsumer; + android::sp mVirtualDisplay; + android::sp mFrameProxy; + Minicap::FrameAvailableListener* mUserFrameAvailableListener; + bool mHaveBuffer; + bool mHaveRunningDisplay; + android::CpuConsumer::LockedBuffer mBuffer; + + int + createVirtualDisplay() { + uint32_t sourceWidth, sourceHeight; + uint32_t targetWidth, targetHeight; + android::status_t err; + + switch (mDesiredOrientation) { + case Minicap::ORIENTATION_90: + sourceWidth = mRealHeight; + sourceHeight = mRealWidth; + targetWidth = mDesiredHeight; + targetHeight = mDesiredWidth; + break; + case Minicap::ORIENTATION_270: + sourceWidth = mRealHeight; + sourceHeight = mRealWidth; + targetWidth = mDesiredHeight; + targetHeight = mDesiredWidth; + break; + case Minicap::ORIENTATION_180: + sourceWidth = mRealWidth; + sourceHeight = mRealHeight; + targetWidth = mDesiredWidth; + targetHeight = mDesiredHeight; + break; + case Minicap::ORIENTATION_0: + default: + sourceWidth = mRealWidth; + sourceHeight = mRealHeight; + targetWidth = mDesiredWidth; + targetHeight = mDesiredHeight; + break; + } + + // Set up virtual display size. + android::Rect layerStackRect(sourceWidth, sourceHeight); + android::Rect visibleRect(targetWidth, targetHeight); + + // Create a Surface for the virtual display to write to. + MCINFO("Creating SurfaceComposerClient"); + android::sp sc = new android::SurfaceComposerClient(); + + MCINFO("Performing SurfaceComposerClient init check"); + if ((err = sc->initCheck()) != android::NO_ERROR) { + MCERROR("Unable to initialize SurfaceComposerClient"); + return err; + } + + // This is now REQUIRED in O Developer Preview 1 or there's a segfault + // when the sp goes out of scope. + sc = NULL; + + // Create virtual display. + MCINFO("Creating virtual display"); + mVirtualDisplay = android::SurfaceComposerClient::createDisplay( + /* const String8& displayName */ android::String8("minicap"), + /* bool secure */ true + ); + + MCINFO("Creating buffer queue"); + android::BufferQueue::createBufferQueue(&mBufferProducer, &mBufferConsumer, false); + + MCINFO("Setting buffer options"); + mBufferConsumer->setDefaultBufferSize(targetWidth, targetHeight); + mBufferConsumer->setDefaultBufferFormat(android::PIXEL_FORMAT_RGBA_8888); + + MCINFO("Creating CPU consumer"); + mConsumer = new android::CpuConsumer(mBufferConsumer, 3, false); + mConsumer->setName(android::String8("minicap")); + + MCINFO("Creating frame waiter"); + mFrameProxy = new FrameProxy(mUserFrameAvailableListener); + mConsumer->setFrameAvailableListener(mFrameProxy); + + MCINFO("Publishing virtual display"); + android::SurfaceComposerClient::Transaction t; + t.setDisplaySurface(mVirtualDisplay, mBufferProducer); + t.setDisplayProjection(mVirtualDisplay, + android::DISPLAY_ORIENTATION_0, layerStackRect, visibleRect); + t.setDisplayLayerStack(mVirtualDisplay, 0); // default stack + t.apply(); + + mHaveRunningDisplay = true; + + return 0; + } + + void + destroyVirtualDisplay() { + MCINFO("Destroying virtual display"); + android::SurfaceComposerClient::destroyDisplay(mVirtualDisplay); + + if (mHaveBuffer) { + mConsumer->unlockBuffer(mBuffer); + mHaveBuffer = false; + } + + mBufferProducer = NULL; + mBufferConsumer = NULL; + mConsumer = NULL; + mFrameProxy = NULL; + mVirtualDisplay = NULL; + + mHaveRunningDisplay = false; + } + + static Minicap::Format + convertFormat(android::PixelFormat format) { + switch (format) { + case android::PIXEL_FORMAT_NONE: + return FORMAT_NONE; + case android::PIXEL_FORMAT_CUSTOM: + return FORMAT_CUSTOM; + case android::PIXEL_FORMAT_TRANSLUCENT: + return FORMAT_TRANSLUCENT; + case android::PIXEL_FORMAT_TRANSPARENT: + return FORMAT_TRANSPARENT; + case android::PIXEL_FORMAT_OPAQUE: + return FORMAT_OPAQUE; + case android::PIXEL_FORMAT_RGBA_8888: + return FORMAT_RGBA_8888; + case android::PIXEL_FORMAT_RGBX_8888: + return FORMAT_RGBX_8888; + case android::PIXEL_FORMAT_RGB_888: + return FORMAT_RGB_888; + case android::PIXEL_FORMAT_RGB_565: + return FORMAT_RGB_565; + case android::PIXEL_FORMAT_BGRA_8888: + return FORMAT_BGRA_8888; + case android::PIXEL_FORMAT_RGBA_5551: + return FORMAT_RGBA_5551; + case android::PIXEL_FORMAT_RGBA_4444: + return FORMAT_RGBA_4444; + default: + return FORMAT_UNKNOWN; + } + } +}; + +int +minicap_try_get_display_info(int32_t displayId, Minicap::DisplayInfo* info) { + android::sp dpy = android::SurfaceComposerClient::getBuiltInDisplay(displayId); + + android::Vector configs; + android::status_t err = android::SurfaceComposerClient::getDisplayConfigs(dpy, &configs); + + if (err != android::NO_ERROR) { + MCERROR("SurfaceComposerClient::getDisplayInfo() failed: %s (%d)\n", error_name(err), err); + return err; + } + + int activeConfig = android::SurfaceComposerClient::getActiveConfig(dpy); + if(static_cast(activeConfig) >= configs.size()) { + MCERROR("Active config %d not inside configs (size %zu)\n", activeConfig, configs.size()); + return android::BAD_VALUE; + } + android::DisplayInfo dinfo = configs[activeConfig]; + + info->width = dinfo.w; + info->height = dinfo.h; + info->orientation = dinfo.orientation; + info->fps = dinfo.fps; + info->density = dinfo.density; + info->xdpi = dinfo.xdpi; + info->ydpi = dinfo.ydpi; + info->secure = dinfo.secure; + info->size = sqrt(pow(dinfo.w / dinfo.xdpi, 2) + pow(dinfo.h / dinfo.ydpi, 2)); + + return 0; +} + +Minicap* +minicap_create(int32_t displayId) { + return new MinicapImpl(displayId); +} + +void +minicap_free(Minicap* mc) { + delete mc; +} + +void +minicap_start_thread_pool() { + android::ProcessState::self()->startThreadPool(); +} From 3bcec4234ddd6981212c9304f273780747384baa Mon Sep 17 00:00:00 2001 From: Crepieux Pierre Date: Wed, 4 Sep 2019 16:42:53 +0200 Subject: [PATCH 2/2] To cope with API changes in the SurfaceComposer we can replace getBuiltInDisplay (which has been removed) with getPhysicalDisplayToken. --- jni/minicap-shared/aosp/Android.mk | 2 ++ jni/minicap-shared/aosp/Makefile | 10 ++++++++++ .../aosp/libs/android-29/arm64-v8a/minicap.so | Bin 0 -> 29080 bytes jni/minicap-shared/aosp/src/minicap_29.cpp | 2 +- 4 files changed, 13 insertions(+), 1 deletion(-) create mode 100755 jni/minicap-shared/aosp/libs/android-29/arm64-v8a/minicap.so diff --git a/jni/minicap-shared/aosp/Android.mk b/jni/minicap-shared/aosp/Android.mk index 9be0f59f..40a4981b 100644 --- a/jni/minicap-shared/aosp/Android.mk +++ b/jni/minicap-shared/aosp/Android.mk @@ -7,6 +7,8 @@ LOCAL_MODULE_TAGS := optional ifneq ($(OVERRIDE_PLATFORM_SDK_VERSION),) LOCAL_SRC_FILES += src/minicap_$(OVERRIDE_PLATFORM_SDK_VERSION).cpp +else ifeq ($(PLATFORM_SDK_VERSION),29) +LOCAL_SRC_FILES += src/minicap_29.cpp else ifeq ($(PLATFORM_SDK_VERSION),28) LOCAL_SRC_FILES += src/minicap_28.cpp else ifeq ($(PLATFORM_SDK_VERSION),27) diff --git a/jni/minicap-shared/aosp/Makefile b/jni/minicap-shared/aosp/Makefile index dc6b8e27..0dd853dc 100644 --- a/jni/minicap-shared/aosp/Makefile +++ b/jni/minicap-shared/aosp/Makefile @@ -48,6 +48,7 @@ all: \ libs/android-28/arm64-v8a/minicap.so \ libs/android-28/x86/minicap.so \ libs/android-28/x86_64/minicap.so \ + libs/android-29/arm64-v8a/minicap.so \ libs/android-9/armeabi-v7a/minicap.so: $(SOURCES) src/minicap_9.cpp mkdir -p $(@D) @@ -606,3 +607,12 @@ libs/android-28/mips64/minicap.so: $(SOURCES) src/minicap_28.cpp -v $(this_dir):/app \ -v $(this_dir)$(@D):/artifacts \ openstf/aosp:jdk8 /aosp.sh build aosp_mips64-eng minicap + +libs/android-29/arm64-v8a/minicap.so: $(SOURCES) src/minicap_29.cpp + mkdir -p $(@D) + docker run --rm \ + -a stdout -a stderr \ + -v /media/aosp/android-10.0.0_r2:/aosp \ + -v $(this_dir):/app \ + -v $(this_dir)$(@D):/artifacts \ + openstf/aosp:jdk8 /aosp.sh build aosp_arm64-eng minicap diff --git a/jni/minicap-shared/aosp/libs/android-29/arm64-v8a/minicap.so b/jni/minicap-shared/aosp/libs/android-29/arm64-v8a/minicap.so new file mode 100755 index 0000000000000000000000000000000000000000..ecddadae3283ab5dcca851618c858f12b92bd4e3 GIT binary patch literal 29080 zcmeHw3s{t8+W#{Q;(#YmBt(S)HSrkW5z}>sgF+$@prUII0}Kwz$(cd%u!(3zO6H`M znHFi=0%}Jqs9f<-Yqq&jGdE@VGtS|Ed?1`675xdeB z#WklIMUP;zb61i^%MwnRugsI37#~yO*{ET;lXSl&F zZt$nw;EitZPu<`@xxs_c$(_ZobAva!!9y_KJM&ZJ20!8k_rf6W%+K9!@EvY&pRS$z zNpOP~1NZA>d_Lqx|5-QqJ8tmHZt(t?Xq~k;&JAvLgKuzy?{b6hcZ2Wp={%l0x_6Fe zxWSjX!M_9ES)R>3I`?1f1}}Ak|G^Eu5qMZ9{rj>T{Dd1n|LX?-40vbl`qGX52hw`j zgZV4_TX(E4RBrR8ID4=?I*DawnXp{+3*q&88K_b44;0)tK?Z2ert%T`m-KaUGOv{h zo2~e_>12Sf`z_sM{mF`-a7BMN`YRMI^Uab0vx0X=y9f_7%79kE|Ec)TjFo|A1@}?> zH&2%V?th!&zbs3}t7XEbD*iVq{`t0kKjgj9F3+*DqQ9aatN71Nkb%hxen`Rn6`a>w z4LSKKA0sQSQ}p*Kc%b6HK*1kZ+LaX}11$=EyOMu@rC**^@Cv2gYL|NVEA5@Av@285 zrvrxSKlaZ9-qrX=l>Ysen&=GR!IBZDa+F~?J?L=b!PY34KA!+J+l@Zsg)}DMrNJu* zFQlPMBPi3s9b-OhO%l!*p%o;cnWJMGa*tON^V51lN8_nXiNP#O_H`!|ba>H_reXB= zPv)E`>-F8SpxZ-wnI7+wQGd>!xo^>hP_O65Z#~^@!M^X81m|yi=Dn2a9bHmp??1O- z^QuEXA6xols9bqkhaP?Ypn6TAQ`8#q{8d3kJ^c`aqL1^eKNME6C5zDYfMn zSVvoni4m`}^NVs#7B0wFE((elDpw0jIhHeGgo5QLv{0eB1$0rEUzDF?ETKz-A*ak} z$jdJ>7UZumv82S9SZ0_P8KtNg@+>A(>V%oH0ZGPkNsh&2w3+gOMUCT_)n>HV3^p@F zxrUPB;)10lp2)>E%W}g)lg*HuZ!IY>E;r;Cy&t$o~)KqGUoFF$& zfZ|h=(+yG9l0+g=iPJ5{5_5iztdMFc&MnO`S>oeKE7H)JPHb_JwX{&u$?gzSWNb+( z7e+>v78MldESBBIr_D%Ck1#|=B>^(!DxiDgv1FQTDzhn?h~?K?$3{xkxoaYi5KS!X z7=IKO#Tc!osBu=4ZJNbcXwok=<`)>V3rtD*R-35^4X4%^qLxtxBalKjTJatGy@U4& zaGng`va1Q{HcNid!ig>h$`DGoVQ`{R9Y;r0veA~m)Rcf>RbYy{Ns5llFS`B!-un`^S#EXB(^ zxKNfSq1S#*BgSDx)*~}ZF;a^1@)x?x&#&<{0lt)wWM@`)-e@@;uMBWpc3k>9E&^_{ z7&Qi!rJ9#pv6U4lm1Yz#HWkGe{)$jtmj^`*3;W;ros{|FY$}q_{D0|X;`jH3?H({W$KI^ zG3i{w6E?%SkwdB4%RHA#Y7EHA1h78-|9h`AMvS6rP1(P z%%h|LiZH)Qu@w9p4#vSjVewLvA+Ol7%xKAl4>aUA$1$F}$;P7i@B5h`HK%0xzZb2rW)qfjX&gC|?|#Bdz3#5he!=XQ`|1}Ae@!3#g88rN8~66V z)F+!0YoY{ z26Qf$koFVKznti_z-G*DHy9(G0A`wO#$2P#=puD9(mI@GTuj{OkrZdgVIv0H3c-c>a3;vdZr@G)r6g<-fKdRtaF8I$1 zZg#;3(9JzcNtQ&M`5CO>n_TeuQ)RuaE_kMbSG(W^3SQ%a+Z4Rn1>dgV7hUid6+B#d z-opFq;uI#82p7Cb(NA!}J$15vstZ0*!K+>Hq%pF7jSIdk?1Dz5LR?knI!1w2r| zy9l^e!0DMWFW~}?NA1oMA>f0ZDBkB5@L>Y36L37rca{VJ*E&%g2LxPvUnf(*`w043 z0^V1^%>wQ(;3WbcAmC*JF1{~VF5p81{YnAvCg7U{JXpZD3OL@1aF%KTk8+}n)d;w_ zFT5z=%2p>^4ILhVGKx+4m&Lb_s1hJD?brRJ%K=UxWXhDVDMN@2AHl)Vky8_sr=?8N zh7Yk$8j?Fq8%qa3JeAaDOHY%vOXzX34@-?to0*uNo|uwsh>K57jE`e+@%lJJO3Yn& z(!gdV&qz+0lWd4jOG`;}av5p*DG*8QrJ9kM++jXGQjCeoaq*eI;JrOYdXlXz!lP`SNA8Fv7Z;gW$DGH>kHRSH zOY<$ZQe%NOSAHMChfUKbCLwKNE~mw%OS#i0C8f+kPjqyK=e4+N#~T(4JI{`kK5Y)& z-1@kfrkiYH*B6)2(?+WgOHSe4mSUJ0KQkq5E}#rUd~(XH=?R87eTJUtlhQCA<{IKN z6Vo%&rDSEyO^qkh#N@;bHYa6PQk)?sDJ6D>OQp^M7n?duo1?tR;KSeHai@G!o{(yj z1@8gfF>|g#dAH^ct0m_S{?1KQ^yr+D5*K%=rP&2|Bc{{Dcg(6Y%1#H656eiLiC#*X zmGKLsLw-g{ZNx)L?T}n;QLzoZVa?AqDIf-$6>nl`hpZ^2A(xnpNs$P*n0(u#N9&lXzxq!4%oOeEfe_Z< zdN61sXgKI8(2<}TIGzZj2+&*@CV*}QHG>YoMqUXT0a^{Z9kdZN3mbnE=sG$8;4rig zR15l7Y}h)`4?#0QPlJ|#Hi1@x`eP%m0UZn42s#<`6lezMMbM+zSOU>N4K~gM&=PFu zC7?FYO3-zn)u2_N^`QGePk|lWkzIz=10QG!--zv7my5TrZIA}BINKopC4A4N(RiF`| z^`P|m8Y+CRQ>{p2s#U?N{@vxf8N%rtVuqf${}4VFulc~yG-n|^2`}>Nij$J7|G~h> z{{ZrjK4Y2P2l_tcvBPt-*A~sAK96;O9LYx^zj1VdF)>m_7jhxn`FQzba8W!giQCJk z5|XdND;)B5oyf`WcD$+}r)yrwZXaHizzYaWz1i=FfIo!%2+2FC_cGuzj9qGDXL5hE zV-<~UH}bKNS3w>~?RC~qdFd|2ngM(rIz>ExQ5ymc_>P!l`Ikyr5K|5?aKLT>IvPB9&U+y?oxB=0aD+xw67EtU6B_VGJEIvSvJTvn^<*ec!T<`Cv+KFsWQc(E-_gP8qHw}DY- z)gi-)$MC**?MJ<%3Gy?LHOJu9l{rR2rt8Ya5k3mnmwM?Oec@}hN8j`Bc4ZmO-E@wx z;pYSokMclXvg!c>ETH6~qjxtGT%U7$8N2E0BnG?+Dp1&89r zG+Du+8e=dE$E(p8tWn`(e7fx54Hg#t;BYpq%8NNFm$K;cAhw@kqPQupo=O{hL7V&Q z97nMnd#iMgGl+B8nguOP<-MT?WYqqzLv)T1mG^lS;%!p*8Q!{bI`TBF_UfGY+G~S! z4&={Hxzr#Bnk#z8B{duF4__+SV`XWmR9*PT=Mt@{#s-@@iE z=+Cb}DbMGi%k4r>1xhwKBW0T})P0A;rmhLPuXvRAZh+kxTx;r8ejyF2C6y|c@ipoj zcE;O&3|rTTeDlP+yt{2^0>%dW+jXjtlhXBzfl}L>)v72B({u|N$d=$tDBB+Nwyzg# zoi;VyB^$|pqHp_klYp1_x8t5c?bl_3PEC(?+_!K0^^1aSf^Z!n=oARH5rWSPg1&$6 zcAr_ob%bntsaJ4I>q=E^Yb>)%efopc_jMY*#5+on&(@XtTJ&MvrLHk8;Qd7#8YfL% zgQ6awywlim=pB7DtRbYDEe~1cRU0yrIYM-*mXJo)5>mpVL$u6+< z-An$ps>Uf)XGjwCt6{%NQya30Xt!GUb+7^DQ$jMBgJPg@T8^=GIZ0UC zVRqtDH|A(v=~3Idmf6!W_stmlG*_C{%$|)Ho76f-E@(68Q9fTF!tBfh&GD)?_kbf={2zBatg+i(g!sES)jcBK9jAo<5RU;Xv~E8vPj%NW~6(vaW$iL z4&0+UY8L4lG=9u4WE5M1oGEiR$R7T&xgN(3|7NVOxYuZ?$<{Sg_5{rX?G0K48o(N= zVejx{Td+<_SS{q=s9BWe53IlD58nNu>!^!SMa%174Awt=?Uk;v(s+{k5bGYTXE?)1 zYaYg!bIqe;;UVCBJ^SiL+v9v)lGd{N6eW3XL~c*Q;o$6BoMXAR+=pn;$zx@ZmNRTFYUepQ2+gQ%p} zUD5Mp4P1V8&VIDJy?=PSd0V70j2wg(_{nSSU|MT6bq^pG+ga>ASgUJrZI01LqmRaB z1iFL8Df3BN` zdvT2Z0KR#U&OyG+=-;+M%;BlT;6VM`CvKmF?7g3ZzjW?!+B@(@sW zMjcc~XUyxsow=y$V^@dD`Y!^{!k%+R9XR}~`nKU3>}#4)ItNotJt^Z@!w8!qV@@Ag zeeG)%ANWq)7WPSb+8;sBVy&S%KS!M{=#wU3*Dx;~m@^vc3-xW%IA&_i25Rre$a%Pc zYk{u@-i+}*RV~le7r;w>NO?s*%YvBW4ZcG19a83ArP#&MuKS@DS|ER;t)0Rp) z{i9ZaF27yp2+}dT9A8k~0bm+BKd53HO^Dswh;e*SW$(9()p}zLI1vAxz2aKVAirCn z`wzrymSXNFwIvHNrvayStX5*K06!77)aGkwOAGpr;-xw40HyY~fa0EhOVdzU)`Z*; zPkmmAI+})3zEt*Iz&f-m^){(pYtb$pWK!&1Vx%+8wf^2w3}*#8&!{jrsPCKB-Z!~v z?Yha=7PE$C#Ic#%c*{1FJ87+iP4k_InUz0s7Gp=d_WsFQ*j{^+HB7Z?>f3TKA6ECM zZCl;5w(YPwy6q>{unxY+{&UoMZY}OzF!!iVYCreekq;TZ7BZZPuve+%d$3pW$iaUzcop>M{7-u!Kikt@*ye$K4P%SOgw)T+dr0{>jQLGxgP$NLUs=k0 zJ`Y~H4^hrldaP;KOK=}D8*AY#tce*|8`H5yrq%vjd^g(GMLKJJ3%kzttiDN@56HK) zUm<76zhjn~?X#un98crE3~k7$tT413Mg4S7v?h$5;Af$u@LB0$XxS3OPH;J`?Ofgn z`2i3A^Qs$d8Cl6X2c11=Ju6LPj*lU;jo0CvfUyCazMlFPJgY;V{p;R`>@xIbwY9yP zg)`0S(aeE;ZXce7$>RfkeHpo-aZ%Y*-9k1yAR{^mdEQd7pk<4P>^HzOre!_+Qe5Fx z`j&B8cA`dU3y=mb;uw%UpEO_s2EJtvD8@yZC+YSJ+H~4UJvuf3aP7cItmQ<89*U{4V(sLE6%~^YRjir3`Dco+ z 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 literal 0 HcmV?d00001 diff --git a/jni/minicap-shared/aosp/src/minicap_29.cpp b/jni/minicap-shared/aosp/src/minicap_29.cpp index c5a04d39..fc4bea20 100644 --- a/jni/minicap-shared/aosp/src/minicap_29.cpp +++ b/jni/minicap-shared/aosp/src/minicap_29.cpp @@ -340,7 +340,7 @@ class MinicapImpl: public Minicap int minicap_try_get_display_info(int32_t displayId, Minicap::DisplayInfo* info) { - android::sp dpy = android::SurfaceComposerClient::getBuiltInDisplay(displayId); + android::sp dpy = android::SurfaceComposerClient::getPhysicalDisplayToken(displayId); android::Vector configs; android::status_t err = android::SurfaceComposerClient::getDisplayConfigs(dpy, &configs);