Snap for 5558509 from f888c9327f472ed02c4a5ae240ec5f6fa39fff54 to qt-release (d4d32206) · Commits · e / os / android_frameworks_native

cmds/installd/InstalldNativeService.cpp

+0 −10

Original line number	Diff line number	Diff line
		@@ -581,10 +581,6 @@ binder::Status InstalldNativeService::clearAppData(const std::unique_ptr<std::st
		// No code cache on shared storage
		} else {
		// Clear everything on shared storage
		path = StringPrintf("%s/Android/sandbox/%s", extPath.c_str(), pkgname);
		if (delete_dir_contents(path, true) != 0) {
		res = error("Failed to delete contents of " + path);
		}
		path = StringPrintf("%s/Android/data/%s", extPath.c_str(), pkgname);
		if (delete_dir_contents(path, true) != 0) {
		res = error("Failed to delete contents of " + path);
		@@ -668,10 +664,6 @@ binder::Status InstalldNativeService::destroyAppData(const std::unique_ptr<std::
		}

		auto extPath = findDataMediaPath(uuid, userId);
		path = StringPrintf("%s/Android/sandbox/%s", extPath.c_str(), pkgname);
		if (delete_dir_contents_and_dir(path, true) != 0) {
		res = error("Failed to delete " + path);
		}
		path = StringPrintf("%s/Android/data/%s", extPath.c_str(), pkgname);
		if (delete_dir_contents_and_dir(path, true) != 0) {
		res = error("Failed to delete " + path);
		@@ -1694,8 +1686,6 @@ binder::Status InstalldNativeService::getAppSize(const std::unique_ptr<std::stri
		}

		ATRACE_BEGIN("external");
		auto sandboxPath = create_data_media_package_path(uuid_, userId, "sandbox", pkgname);
		calculate_tree_size(sandboxPath, &extStats.dataSize);
		auto extPath = create_data_media_package_path(uuid_, userId, "data", pkgname);
		collectManualStats(extPath, &extStats);
		auto mediaPath = create_data_media_package_path(uuid_, userId, "media", pkgname);

include/audiomanager/IAudioManager.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ public:
		RELEASE_PLAYER = IBinder::FIRST_CALL_TRANSACTION + 3,
		TRACK_RECORDER = IBinder::FIRST_CALL_TRANSACTION + 4,
		RECORDER_EVENT = IBinder::FIRST_CALL_TRANSACTION + 5,
		RELEASE_RECORDER = IBinder::FIRST_CALL_TRANSACTION + 6,
		};

		DECLARE_META_INTERFACE(AudioManager)
		@@ -52,6 +53,7 @@ public:
		/oneway/ virtual status_t releasePlayer(audio_unique_id_t piid) = 0;
		virtual audio_unique_id_t trackRecorder(const sp<IBinder>& recorder) = 0;
		/oneway/ virtual status_t recorderEvent(audio_unique_id_t riid, recorder_state_t event) = 0;
		/oneway/ virtual status_t releaseRecorder(audio_unique_id_t riid) = 0;
		};

		// ----------------------------------------------------------------------------

libs/graphicsenv/GpuStatsInfo.cpp

+16 −0

Original line number	Diff line number	Diff line
		@@ -37,6 +37,8 @@ status_t GpuStatsGlobalInfo::writeToParcel(Parcel* parcel) const {
		if ((status = parcel->writeInt32(vulkanVersion)) != OK) return status;
		if ((status = parcel->writeInt32(cpuVulkanVersion)) != OK) return status;
		if ((status = parcel->writeInt32(glesVersion)) != OK) return status;
		if ((status = parcel->writeInt32(angleLoadingCount)) != OK) return status;
		if ((status = parcel->writeInt32(angleLoadingFailureCount)) != OK) return status;
		return OK;
		}

		@@ -53,6 +55,8 @@ status_t GpuStatsGlobalInfo::readFromParcel(const Parcel* parcel) {
		if ((status = parcel->readInt32(&vulkanVersion)) != OK) return status;
		if ((status = parcel->readInt32(&cpuVulkanVersion)) != OK) return status;
		if ((status = parcel->readInt32(&glesVersion)) != OK) return status;
		if ((status = parcel->readInt32(&angleLoadingCount)) != OK) return status;
		if ((status = parcel->readInt32(&angleLoadingFailureCount)) != OK) return status;
		return OK;
		}

		@@ -64,6 +68,8 @@ std::string GpuStatsGlobalInfo::toString() const {
		StringAppendF(&result, "driverBuildTime = %" PRId64 "\n", driverBuildTime);
		StringAppendF(&result, "glLoadingCount = %d\n", glLoadingCount);
		StringAppendF(&result, "glLoadingFailureCount = %d\n", glLoadingFailureCount);
		StringAppendF(&result, "angleLoadingCount = %d\n", angleLoadingCount);
		StringAppendF(&result, "angleLoadingFailureCount = %d\n", angleLoadingFailureCount);
		StringAppendF(&result, "vkLoadingCount = %d\n", vkLoadingCount);
		StringAppendF(&result, "vkLoadingFailureCount = %d\n", vkLoadingFailureCount);
		StringAppendF(&result, "vulkanVersion = %d\n", vulkanVersion);
		@@ -78,6 +84,8 @@ status_t GpuStatsAppInfo::writeToParcel(Parcel* parcel) const {
		if ((status = parcel->writeUint64(driverVersionCode)) != OK) return status;
		if ((status = parcel->writeInt64Vector(glDriverLoadingTime)) != OK) return status;
		if ((status = parcel->writeInt64Vector(vkDriverLoadingTime)) != OK) return status;
		if ((status = parcel->writeInt64Vector(angleDriverLoadingTime)) != OK) return status;
		if ((status = parcel->writeBool(cpuVulkanInUse)) != OK) return status;
		return OK;
		}

		@@ -87,6 +95,8 @@ status_t GpuStatsAppInfo::readFromParcel(const Parcel* parcel) {
		if ((status = parcel->readUint64(&driverVersionCode)) != OK) return status;
		if ((status = parcel->readInt64Vector(&glDriverLoadingTime)) != OK) return status;
		if ((status = parcel->readInt64Vector(&vkDriverLoadingTime)) != OK) return status;
		if ((status = parcel->readInt64Vector(&angleDriverLoadingTime)) != OK) return status;
		if ((status = parcel->readBool(&cpuVulkanInUse)) != OK) return status;
		return OK;
		}

		@@ -94,11 +104,17 @@ std::string GpuStatsAppInfo::toString() const {
		std::string result;
		StringAppendF(&result, "appPackageName = %s\n", appPackageName.c_str());
		StringAppendF(&result, "driverVersionCode = %" PRIu64 "\n", driverVersionCode);
		StringAppendF(&result, "cpuVulkanInUse = %d\n", cpuVulkanInUse);
		result.append("glDriverLoadingTime:");
		for (int32_t loadingTime : glDriverLoadingTime) {
		StringAppendF(&result, " %d", loadingTime);
		}
		result.append("\n");
		result.append("angleDriverLoadingTime:");
		for (int32_t loadingTime : angleDriverLoadingTime) {
		StringAppendF(&result, " %d", loadingTime);
		}
		result.append("\n");
		result.append("vkDriverLoadingTime:");
		for (int32_t loadingTime : vkDriverLoadingTime) {
		StringAppendF(&result, " %d", loadingTime);

libs/graphicsenv/GraphicsEnv.cpp

+51 −25

Original line number	Diff line number	Diff line
		@@ -160,6 +160,22 @@ void GraphicsEnv::setDriverPathAndSphalLibraries(const std::string path,
		mSphalLibraries = sphalLibraries;
		}

		void GraphicsEnv::hintActivityLaunch() {
		ATRACE_CALL();

		// If there's already graphics driver preloaded in the process, just send
		// the stats info to GpuStats directly through async binder.
		std::lock_guard<std::mutex> lock(mStatsLock);
		if (mGpuStats.glDriverToSend) {
		mGpuStats.glDriverToSend = false;
		sendGpuStatsLocked(GraphicsEnv::Api::API_GL, true, mGpuStats.glDriverLoadingTime);
		}
		if (mGpuStats.vkDriverToSend) {
		mGpuStats.vkDriverToSend = false;
		sendGpuStatsLocked(GraphicsEnv::Api::API_VK, true, mGpuStats.vkDriverLoadingTime);
		}
		}

		void GraphicsEnv::setGpuStats(const std::string& driverPackageName,
		const std::string& driverVersionName, uint64_t driverVersionCode,
		int64_t driverBuildTime, const std::string& appPackageName,
		@@ -220,34 +236,21 @@ void GraphicsEnv::setDriverToLoad(GraphicsEnv::Driver driver) {
		}
		}

		void GraphicsEnv::setDriverLoaded(GraphicsEnv::Api api, bool isLoaded, int64_t driverLoadingTime) {
		void GraphicsEnv::setDriverLoaded(GraphicsEnv::Api api, bool isDriverLoaded,
		int64_t driverLoadingTime) {
		ATRACE_CALL();

		std::lock_guard<std::mutex> lock(mStatsLock);
		GraphicsEnv::Driver driver = GraphicsEnv::Driver::NONE;
		bool isIntendedDriverLoaded = false;
		const bool doNotSend = mGpuStats.appPackageName.empty();
		if (api == GraphicsEnv::Api::API_GL) {
		driver = mGpuStats.glDriverToLoad;
		isIntendedDriverLoaded = isLoaded &&
		((mGpuStats.glDriverFallback == GraphicsEnv::Driver::NONE) \|\|
		(mGpuStats.glDriverToLoad == mGpuStats.glDriverFallback));
		if (doNotSend) mGpuStats.glDriverToSend = true;
		mGpuStats.glDriverLoadingTime = driverLoadingTime;
		} else {
		driver = mGpuStats.vkDriverToLoad;
		isIntendedDriverLoaded =
		isLoaded && (mGpuStats.vkDriverFallback == GraphicsEnv::Driver::NONE);
		}

		sendGpuStatsLocked(driver, isIntendedDriverLoaded, driverLoadingTime);
		if (doNotSend) mGpuStats.vkDriverToSend = true;
		mGpuStats.vkDriverLoadingTime = driverLoadingTime;
		}

		void GraphicsEnv::clearDriverLoadingInfo(GraphicsEnv::Api api) {
		ATRACE_CALL();

		std::lock_guard<std::mutex> lock(mStatsLock);
		if (api == GraphicsEnv::Api::API_GL) {
		mGpuStats.glDriverToLoad = GraphicsEnv::Driver::NONE;
		mGpuStats.glDriverFallback = GraphicsEnv::Driver::NONE;
		}
		sendGpuStatsLocked(api, isDriverLoaded, driverLoadingTime);
		}

		static sp<IGpuService> getGpuService() {
		@@ -260,7 +263,18 @@ static sp<IGpuService> getGpuService() {
		return interface_cast<IGpuService>(binder);
		}

		void GraphicsEnv::sendGpuStatsLocked(GraphicsEnv::Driver driver, bool isDriverLoaded,
		void GraphicsEnv::setCpuVulkanInUse() {
		ATRACE_CALL();

		// Use the same stats lock to protect getGpuService() as well.
		std::lock_guard<std::mutex> lock(mStatsLock);
		const sp<IGpuService> gpuService = getGpuService();
		if (gpuService) {
		gpuService->setCpuVulkanInUse(mGpuStats.appPackageName, mGpuStats.driverVersionCode);
		}
		}

		void GraphicsEnv::sendGpuStatsLocked(GraphicsEnv::Api api, bool isDriverLoaded,
		int64_t driverLoadingTime) {
		ATRACE_CALL();

		@@ -274,19 +288,31 @@ void GraphicsEnv::sendGpuStatsLocked(GraphicsEnv::Driver driver, bool isDriverLo
		"\tdriverBuildTime[%" PRId64 "]\n"
		"\tappPackageName[%s]\n"
		"\tvulkanVersion[%d]\n"
		"\tdriver[%d]\n"
		"\tapi[%d]\n"
		"\tisDriverLoaded[%d]\n"
		"\tdriverLoadingTime[%" PRId64 "]",
		mGpuStats.driverPackageName.c_str(), mGpuStats.driverVersionName.c_str(),
		mGpuStats.driverVersionCode, mGpuStats.driverBuildTime, mGpuStats.appPackageName.c_str(),
		mGpuStats.vulkanVersion, static_cast<int32_t>(driver), isDriverLoaded, driverLoadingTime);
		mGpuStats.vulkanVersion, static_cast<int32_t>(api), isDriverLoaded, driverLoadingTime);

		GraphicsEnv::Driver driver = GraphicsEnv::Driver::NONE;
		bool isIntendedDriverLoaded = false;
		if (api == GraphicsEnv::Api::API_GL) {
		driver = mGpuStats.glDriverToLoad;
		isIntendedDriverLoaded =
		isDriverLoaded && (mGpuStats.glDriverFallback == GraphicsEnv::Driver::NONE);
		} else {
		driver = mGpuStats.vkDriverToLoad;
		isIntendedDriverLoaded =
		isDriverLoaded && (mGpuStats.vkDriverFallback == GraphicsEnv::Driver::NONE);
		}

		const sp<IGpuService> gpuService = getGpuService();
		if (gpuService) {
		gpuService->setGpuStats(mGpuStats.driverPackageName, mGpuStats.driverVersionName,
		mGpuStats.driverVersionCode, mGpuStats.driverBuildTime,
		mGpuStats.appPackageName, mGpuStats.vulkanVersion, driver,
		isDriverLoaded, driverLoadingTime);
		isIntendedDriverLoaded, driverLoadingTime);
		}
		}

libs/graphicsenv/IGpuService.cpp

+24 −0

Original line number	Diff line number	Diff line
		@@ -91,6 +91,17 @@ public:
		outStats->clear();
		return reply.readParcelableVector(outStats);
		}

		virtual void setCpuVulkanInUse(const std::string& appPackageName,
		const uint64_t driverVersionCode) {
		Parcel data, reply;
		data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());

		data.writeUtf8AsUtf16(appPackageName);
		data.writeUint64(driverVersionCode);

		remote()->transact(BnGpuService::SET_CPU_VULKAN_IN_USE, data, &reply, IBinder::FLAG_ONEWAY);
		}
		};

		IMPLEMENT_META_INTERFACE(GpuService, "android.graphicsenv.IGpuService");
		@@ -163,6 +174,19 @@ status_t BnGpuService::onTransact(uint32_t code, const Parcel& data, Parcel* rep

		return OK;
		}
		case SET_CPU_VULKAN_IN_USE: {
		CHECK_INTERFACE(IGpuService, data, reply);

		std::string appPackageName;
		if ((status = data.readUtf8FromUtf16(&appPackageName)) != OK) return status;

		uint64_t driverVersionCode;
		if ((status = data.readUint64(&driverVersionCode)) != OK) return status;

		setCpuVulkanInUse(appPackageName, driverVersionCode);

		return OK;
		}
		case SHELL_COMMAND_TRANSACTION: {
		int in = data.readFileDescriptor();
		int out = data.readFileDescriptor();