1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef APKASSETS_H_ 18 #define APKASSETS_H_ 19 20 #include <utils/RefBase.h> 21 22 #include <memory> 23 #include <string> 24 25 #include "android-base/macros.h" 26 #include "android-base/unique_fd.h" 27 #include "androidfw/Asset.h" 28 #include "androidfw/AssetsProvider.h" 29 #include "androidfw/Idmap.h" 30 #include "androidfw/LoadedArsc.h" 31 #include "androidfw/misc.h" 32 33 namespace android { 34 35 class ApkAssets; 36 37 using ApkAssetsPtr = sp<ApkAssets>; 38 39 // Holds an APK. 40 class ApkAssets : public RefBase { 41 public: 42 // Creates an ApkAssets from a path on device. 43 static ApkAssetsPtr Load(const std::string& path, package_property_t flags = 0U); 44 45 // Creates an ApkAssets from an open file descriptor. 46 static ApkAssetsPtr LoadFromFd(base::unique_fd fd, const std::string& debug_name, 47 package_property_t flags = 0U, off64_t offset = 0, 48 off64_t len = AssetsProvider::kUnknownLength); 49 50 // Creates an ApkAssets from an AssetProvider. 51 // The ApkAssets will take care of destroying the AssetsProvider when it is destroyed. 52 static ApkAssetsPtr Load(std::unique_ptr<AssetsProvider> assets, package_property_t flags = 0U); 53 54 // Creates an ApkAssets from the given asset file representing a resources.arsc. 55 static ApkAssetsPtr LoadTable(std::unique_ptr<Asset> resources_asset, 56 std::unique_ptr<AssetsProvider> assets, 57 package_property_t flags = 0U); 58 59 // Creates an ApkAssets from an IDMAP, which contains the original APK path, and the overlay 60 // data. 61 static ApkAssetsPtr LoadOverlay(const std::string& idmap_path, package_property_t flags = 0U); 62 63 // Path to the contents of the ApkAssets on disk. The path could represent an APk, a directory, 64 // or some other file type. 65 std::optional<std::string_view> GetPath() const; 66 67 const std::string& GetDebugName() const; 68 GetAssetsProvider()69 const AssetsProvider* GetAssetsProvider() const { 70 return assets_provider_.get(); 71 } 72 73 // This is never nullptr. GetLoadedArsc()74 const LoadedArsc* GetLoadedArsc() const { 75 return loaded_arsc_.get(); 76 } 77 GetLoadedIdmap()78 const LoadedIdmap* GetLoadedIdmap() const { 79 return loaded_idmap_.get(); 80 } 81 IsLoader()82 bool IsLoader() const { 83 return (property_flags_ & PROPERTY_LOADER) != 0; 84 } 85 IsOverlay()86 bool IsOverlay() const { 87 return loaded_idmap_ != nullptr; 88 } 89 90 // Returns whether the resources.arsc is allocated in RAM (not mmapped). IsTableAllocated()91 bool IsTableAllocated() const { 92 return resources_asset_ != nullptr && resources_asset_->isAllocated(); 93 } 94 95 bool IsUpToDate() const; 96 97 private: 98 static ApkAssetsPtr LoadImpl(std::unique_ptr<AssetsProvider> assets, 99 package_property_t property_flags, 100 std::unique_ptr<Asset> idmap_asset, 101 std::unique_ptr<LoadedIdmap> loaded_idmap); 102 103 static ApkAssetsPtr LoadImpl(std::unique_ptr<Asset> resources_asset, 104 std::unique_ptr<AssetsProvider> assets, 105 package_property_t property_flags, 106 std::unique_ptr<Asset> idmap_asset, 107 std::unique_ptr<LoadedIdmap> loaded_idmap); 108 109 // Allows us to make it possible to call make_shared from inside the class but still keeps the 110 // ctor 'private' for all means and purposes. 111 struct PrivateConstructorUtil { 112 explicit PrivateConstructorUtil() = default; 113 }; 114 115 public: 116 ApkAssets(PrivateConstructorUtil, std::unique_ptr<Asset> resources_asset, 117 std::unique_ptr<LoadedArsc> loaded_arsc, std::unique_ptr<AssetsProvider> assets, 118 package_property_t property_flags, std::unique_ptr<Asset> idmap_asset, 119 std::unique_ptr<LoadedIdmap> loaded_idmap); 120 121 std::unique_ptr<Asset> resources_asset_; 122 std::unique_ptr<LoadedArsc> loaded_arsc_; 123 124 std::unique_ptr<AssetsProvider> assets_provider_; 125 package_property_t property_flags_ = 0U; 126 127 std::unique_ptr<Asset> idmap_asset_; 128 std::unique_ptr<LoadedIdmap> loaded_idmap_; 129 }; 130 131 } // namespace android 132 133 #endif // APKASSETS_H_