| /* |
| * Copyright (C) 2019 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 |
| */ |
| |
| package android.content.res.loader.test |
| |
| import android.content.Context |
| import android.content.res.AssetFileDescriptor |
| import android.content.res.Configuration |
| import android.content.res.Resources |
| import android.content.res.loader.ResourcesProvider |
| import android.os.ParcelFileDescriptor |
| import android.system.Os |
| import androidx.test.InstrumentationRegistry |
| import org.junit.After |
| import org.junit.Before |
| import java.io.Closeable |
| import java.io.FileOutputStream |
| import java.io.File |
| import java.util.zip.ZipInputStream |
| |
| abstract class ResourceLoaderTestBase { |
| protected val PROVIDER_ONE: String = "FrameworksResourceLoaderTests_ProviderOne" |
| protected val PROVIDER_TWO: String = "FrameworksResourceLoaderTests_ProviderTwo" |
| protected val PROVIDER_THREE: String = "FrameworksResourceLoaderTests_ProviderThree" |
| protected val PROVIDER_FOUR: String = "FrameworksResourceLoaderTests_ProviderFour" |
| |
| // Data type of the current test iteration |
| open lateinit var dataType: DataType |
| |
| protected lateinit var context: Context |
| protected open val resources: Resources |
| get() = context.resources |
| |
| // Track opened streams and ResourcesProviders to close them after testing |
| private val openedObjects = mutableListOf<Closeable>() |
| |
| @Before |
| fun setUpBase() { |
| context = InstrumentationRegistry.getTargetContext() |
| .createConfigurationContext(Configuration()) |
| } |
| |
| @After |
| fun removeAllLoaders() { |
| resources.clearLoaders() |
| context.applicationContext.resources.clearLoaders() |
| openedObjects.forEach { |
| try { |
| it.close() |
| } catch (ignored: Exception) { |
| } |
| } |
| } |
| |
| protected fun String.openProvider(dataType: DataType) |
| :ResourcesProvider = when (dataType) { |
| DataType.APK_DISK_FD -> { |
| val file = context.copiedAssetFile("${this}.apk") |
| ResourcesProvider.loadFromApk(ParcelFileDescriptor.fromFd(file.fd)).apply { |
| file.close() |
| } |
| } |
| DataType.APK_DISK_FD_OFFSETS -> { |
| val asset = context.assets.openFd("${this}.apk") |
| ResourcesProvider.loadFromApk(asset.parcelFileDescriptor, asset.startOffset, |
| asset.length, null).apply { |
| asset.close() |
| } |
| } |
| DataType.ARSC_DISK_FD -> { |
| val file = context.copiedAssetFile("${this}.arsc") |
| ResourcesProvider.loadFromTable(ParcelFileDescriptor.fromFd(file.fd), null).apply { |
| file.close() |
| } |
| } |
| DataType.ARSC_DISK_FD_OFFSETS -> { |
| val asset = context.assets.openFd("${this}.arsc") |
| ResourcesProvider.loadFromTable(asset.parcelFileDescriptor, asset.startOffset, |
| asset.length, null).apply { |
| asset.close() |
| } |
| } |
| DataType.APK_RAM_OFFSETS -> { |
| val asset = context.assets.openFd("${this}.apk") |
| val leadingGarbageSize = 100L |
| val trailingGarbageSize = 55L |
| val fd = loadAssetIntoMemory(asset, leadingGarbageSize.toInt(), |
| trailingGarbageSize.toInt()) |
| ResourcesProvider.loadFromApk(fd, leadingGarbageSize, asset.declaredLength, |
| null).apply { |
| asset.close() |
| fd.close() |
| } |
| } |
| DataType.APK_RAM_FD -> { |
| val asset = context.assets.openFd("${this}.apk") |
| var fd = loadAssetIntoMemory(asset) |
| ResourcesProvider.loadFromApk(fd).apply { |
| asset.close() |
| fd.close() |
| } |
| } |
| DataType.ARSC_RAM_MEMORY -> { |
| val asset = context.assets.openFd("${this}.arsc") |
| var fd = loadAssetIntoMemory(asset) |
| ResourcesProvider.loadFromTable(fd, null).apply { |
| asset.close() |
| fd.close() |
| } |
| } |
| DataType.ARSC_RAM_MEMORY_OFFSETS -> { |
| val asset = context.assets.openFd("${this}.arsc") |
| val leadingGarbageSize = 100L |
| val trailingGarbageSize = 55L |
| val fd = loadAssetIntoMemory(asset, leadingGarbageSize.toInt(), |
| trailingGarbageSize.toInt()) |
| ResourcesProvider.loadFromTable(fd, leadingGarbageSize, asset.declaredLength, |
| null).apply { |
| asset.close() |
| fd.close() |
| } |
| } |
| DataType.SPLIT -> { |
| ResourcesProvider.loadFromSplit(context, "${this}_Split") |
| } |
| DataType.DIRECTORY -> { |
| ResourcesProvider.loadFromDirectory(zipToDir("${this}.apk").absolutePath, null) |
| } |
| } |
| |
| |
| /** Extracts an archive-based asset into a directory on disk. */ |
| private fun zipToDir(name : String, suffix : String = "") : File { |
| val root = File(context.filesDir, name.split('.')[0] + suffix) |
| if (root.exists()) { |
| return root |
| } |
| |
| root.mkdir() |
| ZipInputStream(context.assets.open(name)).use { zis -> |
| while (true) { |
| val entry = zis.nextEntry ?: break |
| val file = File(root, entry.name) |
| if (entry.isDirectory) { |
| continue |
| } |
| |
| file.parentFile.mkdirs() |
| file.outputStream().use { output -> |
| var b = zis.read() |
| while (b != -1) { |
| output.write(b) |
| b = zis.read() |
| } |
| } |
| } |
| } |
| return root |
| } |
| |
| |
| /** Loads the asset into a temporary file stored in RAM. */ |
| private fun loadAssetIntoMemory(asset: AssetFileDescriptor, |
| leadingGarbageSize: Int = 0, |
| trailingGarbageSize: Int = 0 |
| ): ParcelFileDescriptor { |
| val originalFd = Os.memfd_create(asset.toString(), 0 /* flags */); |
| val fd = ParcelFileDescriptor.dup(originalFd) |
| Os.close(originalFd) |
| |
| val input = asset.createInputStream() |
| FileOutputStream(fd.fileDescriptor).use { output -> |
| // Add garbage before the APK data |
| for (i in 0 until leadingGarbageSize) { |
| output.write(Math.random().toInt()) |
| } |
| |
| for (i in 0 until asset.length.toInt()) { |
| output.write(input.read()) |
| } |
| |
| // Add garbage after the APK data |
| for (i in 0 until trailingGarbageSize) { |
| output.write(Math.random().toInt()) |
| } |
| } |
| |
| return fd |
| } |
| |
| enum class DataType { |
| APK_DISK_FD, |
| APK_DISK_FD_OFFSETS, |
| APK_RAM_FD, |
| APK_RAM_OFFSETS, |
| ARSC_DISK_FD, |
| ARSC_DISK_FD_OFFSETS, |
| ARSC_RAM_MEMORY, |
| ARSC_RAM_MEMORY_OFFSETS, |
| SPLIT, |
| DIRECTORY |
| } |
| } |