| /* |
| * Copyright (C) 2020 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 "MultiDisplay.h" |
| |
| #include <stddef.h> // for size_t |
| #include <algorithm> // for max |
| #include <cstdint> // for uint32_t |
| #include <ostream> // for operator<< |
| #include <set> // for set |
| #include <string> // for string, stoi |
| #include <unordered_map> // for unordered_map |
| #include <utility> // for pair, make_pair |
| #include <vector> // for vector |
| |
| #include "android/base/LayoutResolver.h" // for resolveLayout |
| #include "android/base/Log.h" // for LogStreamVoi... |
| #include "android/base/files/Stream.h" // for Stream |
| #include "android/base/files/StreamSerializing.h" // for loadCollection |
| #include "android/cmdline-option.h" // for android_cmdL... |
| #include "android/emulation/MultiDisplayPipe.h" // for MultiDisplay... |
| #include "android/emulation/control/adb/AdbInterface.h" // for AdbInterface |
| #include "android/emulator-window.h" // for emulator_win... |
| #include "android/featurecontrol/FeatureControl.h" // for isEnabled |
| #include "android/featurecontrol/Features.h" // for MultiDisplay |
| #include "android/globals.h" // for android_hw |
| #include "android/hw-sensors.h" // for android_fold... |
| #include "android/recording/screen-recorder.h" // for RecorderStates |
| #include "android/skin/file.h" // for SkinLayout |
| #include "android/skin/rect.h" // for SKIN_ROTATION_0 |
| |
| using android::base::AutoLock; |
| |
| namespace android { |
| |
| static MultiDisplay* sMultiDisplay = nullptr; |
| |
| MultiDisplay::MultiDisplay(const QAndroidEmulatorWindowAgent* const windowAgent, |
| const QAndroidRecordScreenAgent* const recordAgent, |
| bool isGuestMode) |
| : mWindowAgent(windowAgent), |
| mRecordAgent(recordAgent), |
| mGuestMode(isGuestMode) { } |
| |
| //static |
| MultiDisplay* MultiDisplay::getInstance() { |
| return sMultiDisplay; |
| } |
| |
| int MultiDisplay::setMultiDisplay(uint32_t id, |
| int32_t x, |
| int32_t y, |
| uint32_t w, |
| uint32_t h, |
| uint32_t dpi, |
| uint32_t flag, |
| bool add) { |
| int ret = 0; |
| SkinRotation rotation = SKIN_ROTATION_0; |
| LOG(VERBOSE) << "setMultiDisplay id " << id << " " |
| << x << " " << y << " " << w << " " << h << " " |
| << dpi << " " << flag << " " << (add? "add":"del"); |
| if (!featurecontrol::isEnabled(android::featurecontrol::MultiDisplay)) { |
| return -1; |
| } |
| if (android_foldable_any_folded_area_configured()) { |
| return -1; |
| } |
| // TODO (wdu@) Remove this when multidisplay is supported by embedded |
| // emulator. |
| if (android_cmdLineOptions->qt_hide_window) { |
| return -1; |
| } |
| if (mGuestMode) { |
| return -1; |
| } |
| if (add && !multiDisplayParamValidate(id, w, h, dpi, flag)) { |
| return -1; |
| } |
| |
| // fetch rotation from EmulatorWindow |
| // TODO: link to libui source code??? |
| EmulatorWindow* window = emulator_window_get(); |
| if (window) { |
| SkinLayout* layout = emulator_window_get_layout(window); |
| if (layout) { |
| rotation = layout->orientation; |
| } |
| } |
| if (rotation != SKIN_ROTATION_0) { |
| mWindowAgent->showMessage("Please apply multiple displays without rotation", |
| WINDOW_MESSAGE_ERROR, 1000); |
| return -1; |
| } |
| |
| if (add) { |
| ret = createDisplay(&id); |
| if (ret != 0) { |
| return ret; |
| } |
| ret = setDisplayPose(id, x, y, w, h, dpi); |
| if (ret != 0) { |
| return ret; |
| } |
| } else { |
| ret = destroyDisplay(id); |
| if (ret != 0) { |
| return ret; |
| } |
| } |
| |
| // Service in guest has already started through QemuMiscPipe when |
| // bootCompleted. But this service may be killed, e.g., Android low |
| // memory. Send broadcast again to guarantee servce running. |
| // P.S. guest Service has check to avoid duplication. |
| auto adbInterface = emulation::AdbInterface::getGlobal(); |
| if (!adbInterface) { |
| LOG(ERROR) << "Adb interface unavailable"; |
| return -1; |
| } |
| adbInterface->enqueueCommand( |
| {"shell", "am", "broadcast", "-a", |
| "com.android.emulator.multidisplay.START", "-n", |
| "com.android.emulator.multidisplay/" |
| ".MultiDisplayServiceReceiver"}); |
| |
| MultiDisplayPipe* pipe = MultiDisplayPipe::getInstance(); |
| if (pipe) { |
| std::vector<uint8_t> data; |
| pipe->fillData(data, id, w, h, dpi, flag, add); |
| LOG(VERBOSE) << "MultiDisplayPipe send " << (add ? "add":"del") << " id " << id |
| << " width " << w << " height " << h << " dpi " << dpi |
| << " flag " << flag; |
| pipe->send(std::move(data)); |
| } |
| return 0; |
| } |
| |
| bool MultiDisplay::getMultiDisplay(uint32_t id, |
| int32_t* x, |
| int32_t* y, |
| uint32_t* w, |
| uint32_t* h, |
| uint32_t* dpi, |
| uint32_t* flag, |
| uint32_t* cb, |
| bool* enabled) { |
| AutoLock lock(mLock); |
| if (mMultiDisplay.find(id) == mMultiDisplay.end()) { |
| if (enabled) { |
| *enabled = false; |
| } |
| return false; |
| } |
| if (x) { |
| *x = mMultiDisplay[id].pos_x; |
| } |
| if (y) { |
| *y = mMultiDisplay[id].pos_y; |
| } |
| if (w) { |
| *w = mMultiDisplay[id].width; |
| } |
| if (h) { |
| *h = mMultiDisplay[id].height; |
| } |
| if (dpi) { |
| *dpi = mMultiDisplay[id].dpi; |
| } |
| if (flag) { |
| *flag = mMultiDisplay[id].flag; |
| } |
| if (enabled) { |
| *enabled = mMultiDisplay[id].enabled; |
| } |
| LOG(VERBOSE) << "getMultiDisplay " << id << "x " << mMultiDisplay[id].pos_x |
| << " y " << mMultiDisplay[id].pos_y |
| << " w " << mMultiDisplay[id].width |
| << " h " << mMultiDisplay[id].height |
| << " dpi " << mMultiDisplay[id].dpi |
| << " flag " << mMultiDisplay[id].flag |
| << " enable " << mMultiDisplay[id].enabled; |
| return mMultiDisplay[id].enabled; |
| } |
| |
| bool MultiDisplay::getNextMultiDisplay(int32_t start_id, |
| uint32_t* id, |
| int32_t* x, |
| int32_t* y, |
| uint32_t* w, |
| uint32_t* h, |
| uint32_t* dpi, |
| uint32_t* flag, |
| uint32_t* cb) { |
| uint32_t key; |
| std::map<uint32_t, MultiDisplayInfo>::iterator i; |
| |
| AutoLock lock(mLock); |
| if (start_id < 0) { |
| key = 0; |
| } else { |
| key = start_id + 1; |
| } |
| i = mMultiDisplay.lower_bound(key); |
| if (i == mMultiDisplay.end()) { |
| return false; |
| } else { |
| if (id) { |
| *id = i->first; |
| } |
| if (x) { |
| *x = i->second.pos_x; |
| } |
| if (y) { |
| *y = i->second.pos_y; |
| } |
| if (w) { |
| *w = i->second.width; |
| } |
| if (h) { |
| *h = i->second.height; |
| } |
| if (dpi) { |
| *dpi = i->second.dpi; |
| } |
| if (flag) { |
| *flag = i->second.flag; |
| } |
| if (cb) { |
| *cb = i->second.cb; |
| } |
| return true; |
| } |
| } |
| |
| bool MultiDisplay::translateCoordination(uint32_t* x, uint32_t* y, uint32_t* displayId) { |
| if (mGuestMode) { |
| *displayId = 0; |
| return true; |
| } |
| AutoLock lock(mLock); |
| uint32_t totalH, pos_x, pos_y, w, h; |
| getCombinedDisplaySizeLocked(nullptr, &totalH); |
| for (const auto iter : mMultiDisplay) { |
| if (iter.first != 0 && iter.second.cb == 0) { |
| continue; |
| } |
| // QT window uses the top left corner as the origin. |
| // So we need to transform the (x, y) coordinates from |
| // bottom left corner to top left corner. |
| pos_x = iter.second.pos_x; |
| pos_y = totalH - iter.second.height - iter.second.pos_y; |
| w = iter.second.width; |
| h = iter.second.height; |
| if ((*x - pos_x) < w && (*y - pos_y) < h) { |
| *x = *x - pos_x; |
| *y = *y - pos_y; |
| *displayId = iter.first; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void MultiDisplay::setGpuMode(bool isGuestMode, uint32_t w, uint32_t h) { |
| mGuestMode = isGuestMode; |
| if (isGuestMode) { |
| // Guest mode will not start renderer, which in turn will not set the |
| // default display from FrameBuffer. So we set display 0 here. |
| AutoLock lock(mLock); |
| mMultiDisplay.emplace(0, MultiDisplayInfo(0, 0, w, h, 0, 0, true, 0)); |
| } |
| } |
| |
| int MultiDisplay::createDisplay(uint32_t* displayId) { |
| if (mGuestMode) { |
| return -1; |
| } |
| |
| if (displayId == nullptr) { |
| LOG(ERROR) << "null displayId pointer"; |
| return -1; |
| } |
| |
| AutoLock lock(mLock); |
| |
| if (mMultiDisplay.size() > s_maxNumMultiDisplay) { |
| LOG(ERROR) << "cannot create more displays, exceeding limits " |
| << s_maxNumMultiDisplay; |
| return -1; |
| } |
| if (mMultiDisplay.find(*displayId) != mMultiDisplay.end()) { |
| return 0; |
| } |
| |
| // displays created by internal rcCommands |
| if (*displayId == s_invalidIdMultiDisplay) { |
| for (int i = s_displayIdInternalBegin; i < s_maxNumMultiDisplay; i++) { |
| if (mMultiDisplay.find(i) == mMultiDisplay.end()) { |
| *displayId = i; |
| break; |
| } |
| } |
| } |
| if (*displayId == s_invalidIdMultiDisplay) { |
| LOG(ERROR) << "cannot create more internaldisplays, exceeding limits " << |
| s_maxNumMultiDisplay - s_displayIdInternalBegin; |
| return -1; |
| } |
| |
| mMultiDisplay.emplace(*displayId, MultiDisplayInfo()); |
| LOG(VERBOSE) << "create display " << *displayId; |
| return 0; |
| } |
| |
| int MultiDisplay::destroyDisplay(uint32_t displayId) { |
| uint32_t width, height; |
| bool needUIUpdate = false; |
| bool restoreSkin = false; |
| |
| if (mGuestMode) { |
| return -1; |
| } |
| { |
| AutoLock lock(mLock); |
| if (mMultiDisplay.find(displayId) == mMultiDisplay.end()) { |
| return 0; |
| } |
| needUIUpdate = ((mMultiDisplay[displayId].cb != 0) ? true : false); |
| mMultiDisplay.erase(displayId); |
| if (needUIUpdate) { |
| recomputeLayoutLocked(); |
| getCombinedDisplaySizeLocked(&width, &height); |
| if (getNumberActiveMultiDisplaysLocked() == 1) { |
| // only display 0 remains, restore skin |
| restoreSkin = true; |
| } |
| } |
| } |
| |
| if (needUIUpdate) { |
| // stop recording of this display if it is happening. |
| RecorderStates states = mRecordAgent->getRecorderState(); |
| if (states.displayId == displayId && states.state == RECORDER_RECORDING) { |
| mRecordAgent->stopRecording(); |
| } |
| mWindowAgent->setUIDisplayRegion(0, 0, width, height); |
| if (restoreSkin) { |
| mWindowAgent->restoreSkin(); |
| } |
| } |
| LOG(VERBOSE) << "delete display " << displayId; |
| return 0; |
| } |
| |
| int MultiDisplay::setDisplayPose(uint32_t displayId, |
| int32_t x, |
| int32_t y, |
| uint32_t w, |
| uint32_t h, |
| uint32_t dpi) { |
| bool UIUpdate = false; |
| bool checkRecording = false; |
| uint32_t width, height; |
| if (mGuestMode) { |
| return -1; |
| } |
| { |
| AutoLock lock(mLock); |
| if (mMultiDisplay.find(displayId) == mMultiDisplay.end()) { |
| LOG(ERROR) << "cannot find display " << displayId; |
| return -1; |
| } |
| if (mMultiDisplay[displayId].cb != 0 && |
| (mMultiDisplay[displayId].width != w || mMultiDisplay[displayId].height != h)) { |
| checkRecording = true; |
| } |
| mMultiDisplay[displayId].width = w; |
| mMultiDisplay[displayId].height = h; |
| mMultiDisplay[displayId].dpi = dpi; |
| mMultiDisplay[displayId].pos_x = x; |
| mMultiDisplay[displayId].pos_y = y; |
| if (mMultiDisplay[displayId].cb != 0) { |
| if (x == -1 && y == -1) { |
| recomputeLayoutLocked(); |
| } |
| getCombinedDisplaySizeLocked(&width, &height); |
| UIUpdate = true; |
| } |
| } |
| if (checkRecording) { |
| // stop recording of this display if it is happening. |
| RecorderStates states = mRecordAgent->getRecorderState(); |
| if (states.displayId == displayId && states.state == RECORDER_RECORDING) { |
| mRecordAgent->stopRecording(); |
| } |
| } |
| if (UIUpdate) { |
| mWindowAgent->setUIDisplayRegion(0, 0, width, height); |
| } |
| LOG(VERBOSE) << "setDisplayPose " << displayId << " x " << x |
| << " y " << y << " w " << w << " h " << h |
| << " dpi " << dpi; |
| return 0; |
| } |
| |
| int MultiDisplay::getDisplayPose(uint32_t displayId, |
| int32_t* x, |
| int32_t* y, |
| uint32_t* w, |
| uint32_t* h) { |
| if (mGuestMode) { |
| return -1; |
| } |
| AutoLock lock(mLock); |
| if (mMultiDisplay.find(displayId) == mMultiDisplay.end()) { |
| LOG(ERROR) << "cannot find display " << displayId; |
| return -1; |
| } |
| *x = mMultiDisplay[displayId].pos_x; |
| *y = mMultiDisplay[displayId].pos_y; |
| *w = mMultiDisplay[displayId].width; |
| *h = mMultiDisplay[displayId].height; |
| return 0; |
| } |
| |
| int MultiDisplay::setDisplayColorBuffer(uint32_t displayId, uint32_t colorBuffer) { |
| uint32_t width, height; |
| bool noSkin = false; |
| bool needUpdate = false; |
| if (mGuestMode) { |
| return -1; |
| } |
| { |
| AutoLock lock(mLock); |
| if (mMultiDisplay.find(displayId) == mMultiDisplay.end()) { |
| LOG(ERROR) << "cannot find display" << displayId; |
| return -1; |
| } |
| if (mMultiDisplay[displayId].cb == colorBuffer) { |
| return 0; |
| } |
| if (mMultiDisplay[displayId].cb == 0) { |
| mMultiDisplay[displayId].cb = colorBuffer; |
| // first time cb assigned, update the UI |
| needUpdate = true; |
| recomputeLayoutLocked(); |
| getCombinedDisplaySizeLocked(&width, &height); |
| if (getNumberActiveMultiDisplaysLocked() == 2) { |
| //disable skin when first display set, index 0 is the default one. |
| noSkin = true; |
| } |
| } |
| mMultiDisplay[displayId].cb = colorBuffer; |
| } |
| if (noSkin) { |
| mWindowAgent->setNoSkin(); |
| } |
| if (needUpdate) { |
| // Explicitly adjust host window size |
| mWindowAgent->setUIDisplayRegion(0, 0, width, height); |
| } |
| LOG(VERBOSE) << "setDisplayColorBuffer " << displayId << " cb " << colorBuffer; |
| return 0; |
| } |
| |
| int MultiDisplay::getDisplayColorBuffer(uint32_t displayId, uint32_t* colorBuffer) { |
| if (mGuestMode) { |
| return -1; |
| } |
| AutoLock lock(mLock); |
| if (mMultiDisplay.find(displayId) == mMultiDisplay.end()) { |
| return -1; |
| } |
| *colorBuffer = mMultiDisplay[displayId].cb; |
| return 0; |
| } |
| |
| int MultiDisplay::getColorBufferDisplay(uint32_t colorBuffer, uint32_t* displayId) { |
| if (mGuestMode) { |
| return -1; |
| } |
| AutoLock lock(mLock); |
| for (const auto& iter : mMultiDisplay) { |
| if (iter.second.cb == colorBuffer) { |
| *displayId = iter.first; |
| return 0; |
| } |
| } |
| return -1; |
| } |
| |
| void MultiDisplay::getCombinedDisplaySize(uint32_t* w, uint32_t* h) { |
| AutoLock lock(mLock); |
| getCombinedDisplaySizeLocked(w, h); |
| } |
| |
| void MultiDisplay::getCombinedDisplaySizeLocked(uint32_t* w, uint32_t* h) { |
| uint32_t total_h = 0; |
| uint32_t total_w = 0; |
| for (const auto& iter : mMultiDisplay) { |
| if (iter.first == 0 || iter.second.cb != 0) { |
| total_h = std::max(total_h, iter.second.height + iter.second.pos_y); |
| total_w = std::max(total_w, iter.second.width + iter.second.pos_x); |
| } |
| } |
| if (h) |
| *h = total_h; |
| if (w) |
| *w = total_w; |
| } |
| |
| int MultiDisplay::getNumberActiveMultiDisplaysLocked() { |
| int count = 0; |
| for (const auto& iter : mMultiDisplay) { |
| if (iter.first == 0 || iter.second.cb != 0) { |
| count++; |
| } |
| } |
| return count; |
| } |
| |
| /* |
| * Given that there are at most 11 displays, we can iterate through all possible |
| * ways of showing each display in either the first row or the second row. It is |
| * also possible to have an empty row. The best combination is to satisfy the |
| * following two criteria: 1, The combined rectangle which contains all the |
| * displays should have an aspect ratio that is close to the monitor's aspect |
| * ratio. 2, The width of the first row should be close to the width of the |
| * second row. |
| * |
| * Important detail of implementations: the x and y offsets saved in |
| * mMultiDisplay use the bottom-left corner as origin. This coordinates will |
| * be used by glviewport() in Postworker.cpp. However, the x and y offsets saved |
| * by invoking setUIMultiDisplay() will be using top-left corner as origin. Thus, |
| * input coordinates willl be calculated correctly when mouse events are |
| * captured by QT window. |
| * |
| * TODO: We assume all displays pos_x/pos_y is adjustable here. This may |
| * overwrite the specified pos_x/pos_y in setDisplayPos(); |
| */ |
| void MultiDisplay::recomputeLayoutLocked() { |
| uint32_t monitorWidth, monitorHeight; |
| double monitorAspectRatio = 1.0; |
| if (!mWindowAgent->getMonitorRect(&monitorWidth, &monitorHeight)) { |
| LOG(WARNING) << "Fail to get monitor width and height, use default ratio 1.0"; |
| } else { |
| monitorAspectRatio = (double) monitorHeight / (double) monitorWidth; |
| } |
| std::unordered_map<uint32_t, std::pair<uint32_t, uint32_t>> rectangles; |
| for (const auto& iter : mMultiDisplay) { |
| if (iter.first == 0 || iter.second.cb != 0) { |
| rectangles[iter.first] = |
| std::make_pair(iter.second.width, iter.second.height); |
| } |
| } |
| for (const auto& iter : |
| android::base::resolveLayout(rectangles, monitorAspectRatio)) { |
| mMultiDisplay[iter.first].pos_x = iter.second.first; |
| mMultiDisplay[iter.first].pos_y = iter.second.second; |
| } |
| } |
| |
| bool MultiDisplay::multiDisplayParamValidate(uint32_t id, uint32_t w, uint32_t h, |
| uint32_t dpi, uint32_t flag) { |
| // According the Android 9 CDD, |
| // * 120 <= dpi <= 640 |
| // * 320 * (dpi / 160) <= width |
| // * 320 * (dpi / 160) <= height |
| // * Screen aspect ratio cannot be longer (or wider) than 21:9 (or 9:21). |
| // |
| // Also we don't want a screen too big to limit the performance impact. |
| // * 4K might be a good upper limit |
| |
| if (dpi < 120 || dpi > 640) { |
| mWindowAgent->showMessage("dpi should be between 120 and 640", |
| WINDOW_MESSAGE_ERROR, 1000); |
| LOG(ERROR) << "dpi should be between 120 and 640"; |
| return false; |
| } |
| if (w < 320 * dpi / 160 || h < 320 * dpi / 160) { |
| mWindowAgent->showMessage("width and height should be >= 320dp", |
| WINDOW_MESSAGE_ERROR, 1000); |
| LOG(ERROR) << "width and height should be >= 320dp"; |
| return false; |
| } |
| if (!((w <= 4096 && h <= 2160) || (w <= 2160 && h <= 4096))) { |
| mWindowAgent->showMessage("resolution should not exceed 4k (4096*2160)", |
| WINDOW_MESSAGE_ERROR, 1000); |
| LOG(ERROR) << "resolution should not exceed 4k (4096*2160)"; |
| return false; |
| } |
| if (w * 21 < h * 9 || w * 9 > h * 21) { |
| mWindowAgent->showMessage("Aspect ratio cannot be longer (or wider) than 21:9 (or 9:21)", |
| WINDOW_MESSAGE_ERROR, 1000); |
| LOG(ERROR) << "Aspect ratio cannot be longer (or wider) than 21:9 (or 9:21)"; |
| return false; |
| } |
| if (id > s_maxNumMultiDisplay) { |
| mWindowAgent->showMessage("Display index cannot be more than 3", |
| WINDOW_MESSAGE_ERROR, 1000); |
| LOG(ERROR) << "Display index cannot be more than 3"; |
| return false; |
| } |
| return true; |
| } |
| |
| std::map<uint32_t, MultiDisplayInfo> MultiDisplay::parseConfig() { |
| std::map<uint32_t, MultiDisplayInfo> ret; |
| if (!android_cmdLineOptions || !android_cmdLineOptions->multidisplay) { |
| return ret; |
| } |
| std::string s = android_cmdLineOptions->multidisplay; |
| std::vector<uint32_t> params; |
| size_t last = 0, next = 0; |
| while ((next = s.find(",", last)) != std::string::npos) { |
| params.push_back(std::stoi(s.substr(last, next - last))); |
| last = next + 1; |
| } |
| params.push_back(std::stoi(s.substr(last))); |
| if (params.size() < 5 || params.size() % 5 != 0) { |
| LOG(ERROR) << "Not enough parameters for multidisplay command"; |
| return ret; |
| } |
| int i = 0; |
| for (i = 0; i < params.size(); i+=5) { |
| if (params[i] == 0 || params[i] > 3) { |
| LOG(ERROR) << "multidisplay index should only be 1, 2, or 3"; |
| ret.clear(); |
| return ret; |
| } |
| if (multiDisplayParamValidate(params[i], |
| params[i + 1], |
| params[i + 2], |
| params[i + 3], |
| params[i + 4])) { |
| LOG(ERROR) << "Invalid index/width/height/dpi settings for multidisplay command"; |
| ret.clear(); |
| return ret; |
| } |
| ret.emplace(params[i], MultiDisplayInfo(-1, -1, params[i + 1], params[i + 2], |
| params[i + 3], params[i + 4], true)); |
| } |
| return ret; |
| } |
| |
| void MultiDisplay::loadConfig() { |
| // Get the multidisplay configs from startup parameters, if yes, |
| // override the configs in config.ini |
| // This stage happens before the MultiDisplayPipe created (bootCompleted) |
| // or restored (snapshot). MultiDisplay configs will not send to guest |
| // immediately. |
| // For cold boot, MultiDisplayPipe queries configs when it is created. |
| // For snapshot, MultiDisplayPipe query will not happen, instead, |
| // onLoad() function later may overwrite the multidisplay states to |
| // in sync with guest states. |
| if (!featurecontrol::isEnabled(android::featurecontrol::MultiDisplay)) { |
| return; |
| } |
| if (android_foldable_any_folded_area_configured()) { |
| return; |
| } |
| if (mGuestMode) { |
| return; |
| } |
| |
| std::map<uint32_t, MultiDisplayInfo> info = parseConfig(); |
| if (info.size()) { |
| LOG(VERBOSE) << "config multidisplay with command-line"; |
| for (const auto& i : info) { |
| setMultiDisplay(i.first, |
| -1, |
| -1, |
| i.second.width, |
| i.second.height, |
| i.second.dpi, |
| i.second.flag, |
| true); |
| mWindowAgent->updateUIMultiDisplayPage(i.first); |
| } |
| } else { |
| LOG(VERBOSE) << "config multidisplay with config.ini " |
| << android_hw->hw_display1_width |
| << "x" << android_hw->hw_display1_height << " " << |
| android_hw->hw_display2_width << "x" << |
| android_hw->hw_display2_height << " " << |
| android_hw->hw_display3_width << "x" << |
| android_hw->hw_display3_height; |
| if (android_hw->hw_display1_width != 0 && |
| android_hw->hw_display1_height != 0) { |
| LOG(VERBOSE) << " add display 1"; |
| setMultiDisplay(1, |
| android_hw->hw_display1_xOffset, |
| android_hw->hw_display1_yOffset, |
| android_hw->hw_display1_width, |
| android_hw->hw_display1_height, |
| android_hw->hw_display1_density, |
| android_hw->hw_display1_flag, |
| true); |
| mWindowAgent->updateUIMultiDisplayPage(1); |
| } |
| if (android_hw->hw_display2_width != 0 && |
| android_hw->hw_display2_height != 0) { |
| LOG(VERBOSE) << " add display 2"; |
| setMultiDisplay(2, |
| android_hw->hw_display2_xOffset, |
| android_hw->hw_display2_yOffset, |
| android_hw->hw_display2_width, |
| android_hw->hw_display2_height, |
| android_hw->hw_display2_density, |
| android_hw->hw_display2_flag, |
| true); |
| mWindowAgent->updateUIMultiDisplayPage(2); |
| } |
| if (android_hw->hw_display3_width != 0 && |
| android_hw->hw_display3_height != 0) { |
| LOG(VERBOSE) << " add display 3"; |
| setMultiDisplay(3, |
| android_hw->hw_display3_xOffset, |
| android_hw->hw_display3_yOffset, |
| android_hw->hw_display3_width, |
| android_hw->hw_display3_height, |
| android_hw->hw_display3_density, |
| android_hw->hw_display3_flag, |
| true); |
| mWindowAgent->updateUIMultiDisplayPage(3); |
| } |
| } |
| } |
| |
| void MultiDisplay::onSave(base::Stream* stream) { |
| AutoLock lock(mLock); |
| base::saveCollection( |
| stream, mMultiDisplay, |
| [](base::Stream* s, |
| const std::map<uint32_t, MultiDisplayInfo>::value_type& pair) { |
| s->putBe32(pair.first); |
| s->putBe32(pair.second.pos_x); |
| s->putBe32(pair.second.pos_y); |
| s->putBe32(pair.second.width); |
| s->putBe32(pair.second.height); |
| s->putBe32(pair.second.dpi); |
| s->putBe32(pair.second.flag); |
| s->putBe32(pair.second.cb); |
| s->putByte(pair.second.enabled); |
| }); |
| } |
| |
| void MultiDisplay::onLoad(base::Stream* stream) { |
| std::map<uint32_t, MultiDisplayInfo> displaysOnLoad; |
| base::loadCollection(stream, &displaysOnLoad, |
| [this](base::Stream* stream) -> std::map<uint32_t, MultiDisplayInfo>::value_type { |
| const uint32_t idx = stream->getBe32(); |
| const int32_t pos_x = stream->getBe32(); |
| const int32_t pos_y = stream->getBe32(); |
| const uint32_t width = stream->getBe32(); |
| const uint32_t height = stream->getBe32(); |
| const uint32_t dpi = stream->getBe32(); |
| const uint32_t flag = stream->getBe32(); |
| const uint32_t cb = stream->getBe32(); |
| const bool enabled = stream->getByte(); |
| return {idx, {pos_x, pos_y, width, height, dpi, flag, enabled, cb}}; |
| }); |
| // Restore the multidisplays of the snapshot. |
| std::set<uint32_t> ids; |
| uint32_t combinedDisplayWidth = 0; |
| uint32_t combinedDisplayHeight = 0; |
| bool activeBeforeLoad, activeAfterLoad; |
| { |
| AutoLock lock(mLock); |
| for (const auto& iter : mMultiDisplay) { |
| ids.insert(iter.first); |
| } |
| for (const auto& iter: displaysOnLoad) { |
| ids.insert(iter.first); |
| } |
| activeBeforeLoad = getNumberActiveMultiDisplaysLocked() > 1; |
| mMultiDisplay.clear(); |
| mMultiDisplay = displaysOnLoad; |
| activeAfterLoad = getNumberActiveMultiDisplaysLocked() > 1; |
| getCombinedDisplaySizeLocked(&combinedDisplayWidth, &combinedDisplayHeight); |
| } |
| if (activeAfterLoad) { |
| if (!activeBeforeLoad) { |
| mWindowAgent->setNoSkin(); |
| } |
| mWindowAgent->setUIDisplayRegion(0, 0, combinedDisplayWidth, combinedDisplayHeight); |
| } else { |
| if (activeBeforeLoad) { |
| mWindowAgent->setUIDisplayRegion(0, 0, combinedDisplayWidth, combinedDisplayHeight); |
| mWindowAgent->restoreSkin(); |
| } |
| } |
| for (const auto& iter : ids) { |
| mWindowAgent->updateUIMultiDisplayPage(iter); |
| } |
| } |
| |
| } // namespace android |
| |
| void android_init_multi_display(const QAndroidEmulatorWindowAgent* const windowAgent, |
| const QAndroidRecordScreenAgent* const recordAgent, |
| bool isGuestMode) { |
| android::sMultiDisplay = new android::MultiDisplay(windowAgent, recordAgent, isGuestMode); |
| } |
| |
| extern "C" { |
| void android_load_multi_display_config() { |
| if (!android::sMultiDisplay) { |
| LOG(ERROR) << "Multidisplay not initiated yet, cannot config"; |
| return; |
| } |
| android::sMultiDisplay->loadConfig(); |
| } |
| } |
