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

Commit 75a7b25f authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 8822995 from 46f60be4 to tm-qpr1-release 

Change-Id: Ibb6112cd430a89ebebc089ac7a5db66dae841c74
parents 3930089e 46f60be4

cmds/dumpstate/DumpstateInternal.cpp

+5 −5
Original line number Diff line number Diff line
@@ -162,17 +162,16 @@ int DumpFileFromFdToFd(const std::string& title, const std::string& path_string, 
        return 0;

    }

    bool newline = false;

    int poll_timeout_ms = 30 * 1000;

    while (true) {

        uint64_t start_time = Nanotime();

        pollfd fds[] = { { .fd = fd, .events = POLLIN } };

        int ret = TEMP_FAILURE_RETRY(poll(fds, arraysize(fds), 30 * 1000));

        int ret = TEMP_FAILURE_RETRY(poll(fds, arraysize(fds), poll_timeout_ms));

        if (ret == -1) {

            dprintf(out_fd, "*** %s: poll failed: %s\n", path, strerror(errno));

            newline = true;

            break;

        } else if (ret == 0) {

            uint64_t elapsed = Nanotime() - start_time;

            dprintf(out_fd, "*** %s: Timed out after %.3fs\n", path, (float)elapsed / NANOS_PER_SEC);

        } else if (ret == 0 && poll_timeout_ms != 0) {

            dprintf(out_fd, "*** %s: Timed out after %ds\n", path, poll_timeout_ms / 1000 );

            newline = true;

            break;

        } else {
@@ -189,6 +188,7 @@ int DumpFileFromFdToFd(const std::string& title, const std::string& path_string, 
                break;

            }

        }

        poll_timeout_ms = 0;

    }



    if (!newline) dprintf(out_fd, "\n");

services/powermanager/WorkSource.cpp

+10 −2
Original line number Diff line number Diff line
@@ -28,9 +28,16 @@ status_t WorkSource::readFromParcel(const android::Parcel *parcel) { 
        return BAD_VALUE;

    }

    int32_t num;

    int32_t workChainCount;

    status_t ret = parcel->readInt32(&num)

                ?: parcel->readInt32Vector(&mUids)

                ?: parcel->readString16Vector(&mNames);

                ?: parcel->readString16Vector(&mNames)

                ?: parcel->readInt32(&workChainCount);



    if (ret == OK && workChainCount > 0) {

        // We don't yet support WorkChains in native WorkSources.

        return BAD_VALUE;

    }



    return ret;

}
@@ -43,7 +50,8 @@ status_t WorkSource::writeToParcel(android::Parcel *parcel) const { 


    return parcel->writeInt32(mUids.size())

        ?: parcel->writeInt32Vector(mUids)

        ?: parcel->writeString16Vector(mNames);

        ?: parcel->writeString16Vector(mNames)

        ?: parcel->writeInt32(-1);

}



} // namespace android::os

services/powermanager/tests/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ cc_test { 
        "PowerHalWrapperAidlTest.cpp",

        "PowerHalWrapperHidlV1_0Test.cpp",

        "PowerHalWrapperHidlV1_1Test.cpp",

        "WorkSourceTest.cpp",

    ],

    cflags: [

        "-Wall",

services/powermanager/tests/WorkSourceTest.cpp

0 → 100644
+46 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <optional>

#define LOG_TAG "PowerHalLoaderTest"



#include <android-base/logging.h>

#include <android/WorkSource.h>

#include <binder/Parcel.h>

#include <gtest/gtest.h>



#include <future>



using namespace android;

using namespace testing;



TEST(WorkSourceTest, Parcel) {

    std::vector<int32_t> uids = {1, 2};

    using Names = std::vector<std::optional<String16>>;

    std::optional<Names> names = std::make_optional<Names>({std::make_optional(String16("name"))});

    os::WorkSource ws{uids, names};



    Parcel p;

    ws.writeToParcel(&p);

    p.setDataPosition(0);



    os::WorkSource otherWs;

    otherWs.readFromParcel(&p);



    EXPECT_EQ(ws, otherWs);

    EXPECT_EQ(uids, otherWs.getUids());

    EXPECT_EQ(names, otherWs.getNames());

}

services/surfaceflinger/RefreshRateOverlay.cpp

+34 −17
Original line number Diff line number Diff line
@@ -16,9 +16,10 @@ 


#include <algorithm>



#include "RefreshRateOverlay.h"

#include "BackgroundExecutor.h"

#include "Client.h"

#include "Layer.h"

#include "RefreshRateOverlay.h"



#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wconversion"
@@ -56,6 +57,14 @@ SurfaceComposerClient::Transaction createTransaction(const sp<SurfaceControl>& s 


} // namespace



SurfaceControlHolder::~SurfaceControlHolder() {

    // Hand the sp<SurfaceControl> to the helper thread to release the last

    // reference. This makes sure that the SurfaceControl is destructed without

    // SurfaceFlinger::mStateLock held.

    BackgroundExecutor::getInstance().sendCallbacks(

            {[sc = std::move(mSurfaceControl)]() mutable { sc.clear(); }});

}



void RefreshRateOverlay::SevenSegmentDrawer::drawSegment(Segment segment, int left, SkColor color,

                                                         SkCanvas& canvas) {

    const SkRect rect = [&]() {
@@ -210,21 +219,27 @@ auto RefreshRateOverlay::SevenSegmentDrawer::draw(int number, SkColor color, 
    return buffers;

}



std::unique_ptr<SurfaceControlHolder> createSurfaceControlHolder() {

    sp<SurfaceControl> surfaceControl =

            SurfaceComposerClient::getDefault()

                    ->createSurface(String8("RefreshRateOverlay"), kBufferWidth, kBufferHeight,

                                    PIXEL_FORMAT_RGBA_8888,

                                    ISurfaceComposerClient::eFXSurfaceBufferState);

    return std::make_unique<SurfaceControlHolder>(std::move(surfaceControl));

}



RefreshRateOverlay::RefreshRateOverlay(FpsRange fpsRange, bool showSpinner)

      : mFpsRange(fpsRange),

        mShowSpinner(showSpinner),

        mSurfaceControl(SurfaceComposerClient::getDefault()

                                ->createSurface(String8("RefreshRateOverlay"), kBufferWidth,

                                                kBufferHeight, PIXEL_FORMAT_RGBA_8888,

                                                ISurfaceComposerClient::eFXSurfaceBufferState)) {

        mSurfaceControl(createSurfaceControlHolder()) {

    if (!mSurfaceControl) {

        ALOGE("%s: Failed to create buffer state layer", __func__);

        return;

    }



    createTransaction(mSurfaceControl)

            .setLayer(mSurfaceControl, INT32_MAX - 2)

            .setTrustedOverlay(mSurfaceControl, true)

    createTransaction(mSurfaceControl->get())

            .setLayer(mSurfaceControl->get(), INT32_MAX - 2)

            .setTrustedOverlay(mSurfaceControl->get(), true)

            .apply();

}
@@ -233,7 +248,7 @@ auto RefreshRateOverlay::getOrCreateBuffers(Fps fps) -> const Buffers& { 
    if (!mSurfaceControl) return kNoBuffers;



    const auto transformHint =

            static_cast<ui::Transform::RotationFlags>(mSurfaceControl->getTransformHint());

            static_cast<ui::Transform::RotationFlags>(mSurfaceControl->get()->getTransformHint());



    // Tell SurfaceFlinger about the pre-rotation on the buffer.

    const auto transform = [&] {
@@ -247,7 +262,9 @@ auto RefreshRateOverlay::getOrCreateBuffers(Fps fps) -> const Buffers& { 
        }

    }();



    createTransaction(mSurfaceControl).setTransform(mSurfaceControl, transform).apply();

    createTransaction(mSurfaceControl->get())

            .setTransform(mSurfaceControl->get(), transform)

            .apply();



    BufferCache::const_iterator it = mBufferCache.find({fps.getIntValue(), transformHint});

    if (it == mBufferCache.end()) {
@@ -289,21 +306,21 @@ void RefreshRateOverlay::setViewport(ui::Size viewport) { 
    Rect frame((3 * width) >> 4, height >> 5);

    frame.offsetBy(width >> 5, height >> 4);



    createTransaction(mSurfaceControl)

            .setMatrix(mSurfaceControl, frame.getWidth() / static_cast<float>(kBufferWidth), 0, 0,

                       frame.getHeight() / static_cast<float>(kBufferHeight))

            .setPosition(mSurfaceControl, frame.left, frame.top)

    createTransaction(mSurfaceControl->get())

            .setMatrix(mSurfaceControl->get(), frame.getWidth() / static_cast<float>(kBufferWidth),

                       0, 0, frame.getHeight() / static_cast<float>(kBufferHeight))

            .setPosition(mSurfaceControl->get(), frame.left, frame.top)

            .apply();

}



void RefreshRateOverlay::setLayerStack(ui::LayerStack stack) {

    createTransaction(mSurfaceControl).setLayerStack(mSurfaceControl, stack).apply();

    createTransaction(mSurfaceControl->get()).setLayerStack(mSurfaceControl->get(), stack).apply();

}



void RefreshRateOverlay::changeRefreshRate(Fps fps) {

    mCurrentFps = fps;

    const auto buffer = getOrCreateBuffers(fps)[mFrame];

    createTransaction(mSurfaceControl).setBuffer(mSurfaceControl, buffer).apply();

    createTransaction(mSurfaceControl->get()).setBuffer(mSurfaceControl->get(), buffer).apply();

}



void RefreshRateOverlay::animate() {
@@ -312,7 +329,7 @@ void RefreshRateOverlay::animate() { 
    const auto& buffers = getOrCreateBuffers(*mCurrentFps);

    mFrame = (mFrame + 1) % buffers.size();

    const auto buffer = buffers[mFrame];

    createTransaction(mSurfaceControl).setBuffer(mSurfaceControl, buffer).apply();

    createTransaction(mSurfaceControl->get()).setBuffer(mSurfaceControl->get(), buffer).apply();

}



} // namespace android