### Preload a Newly Installed RePlugin Plugin (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Shows how to preload a newly installed plugin, typically used for background updates. This involves first installing the APK file using `RePlugin.install()` and then preloading the `PluginInfo` object returned by the installation process, ensuring the plugin is ready for use. ```Java PluginInfo pi = RePlugin.install("/sdcard/exam_new.apk"); if (pi != null) { RePlugin.preload(pi); } ``` -------------------------------- ### RePlugin API: Plugin Installation and Upgrade Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Documents the RePlugin.install() method used for both installing new plugins and upgrading existing ones. It covers parameters, return values, file handling, and important considerations like deferred upgrades for running plugins and common failure scenarios. ```APIDOC RePlugin.install(apkPath: String): PluginInfo - Installs or upgrades a plugin from the specified APK file path. - Parameters: - apkPath: The absolute path to the plugin's APK file (e.g., "/sdcard/exam.apk"). - Returns: A PluginInfo object if successful, null otherwise. - Behavior: - Moves (not copies) the source APK file to the plugin's installation path. - If the plugin is running, upgrades are cached and applied after all processes using the plugin terminate and restart. - Does not support plugin downgrades, but supports same-version overwrites (since RePlugin 2.1.5). - Best Practices: - Minimize silent installations for non-core plugins to save storage. - Handle plugin download if not found (override RePluginCallbacks.onPluginNotExistsForActivity). - Inform users about plugin size before download. - For upgrades, consider silent upgrades and preloading the new plugin's Dex in a background thread. - If a running plugin needs a mandatory upgrade, prompt the user to restart; otherwise, restart after screen lock. - Common Failure Reasons (returns null): - Signature verification failed (check whitelist or disable verification). - Replugin-host-lib version < 2.1.4 (meta-data issue). - Invalid APK package (try installing directly on device). - Missing SD card read/write permissions if APK is on SD card. - Insufficient internal storage (Logcat: "copyOrMoveApk: Copy/Move Failed"). ``` -------------------------------- ### Java: Install RePlugin Plugin from APK Path Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Example demonstrating how to install a RePlugin plugin using its APK file path. This method is versatile and also handles plugin upgrades. ```Java RePlugin.install("/sdcard/exam.apk"); ``` -------------------------------- ### Preload an Already Installed RePlugin Plugin (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Demonstrates how to preload an already installed plugin using `RePlugin.preload(pluginName)`. This is the most common scenario for optimizing plugin loading. If the plugin is already running, this call is ineffective as the plugin is already in use. ```Java RePlugin.preload("exam"); ``` -------------------------------- ### Java: Upgrade RePlugin Plugin with Dex Preloading Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Illustrates a best practice for upgrading RePlugin plugins: installing the new version and then immediately preloading its Dex to ensure faster subsequent launches, especially useful for silent updates. ```Java PluginInfo pi = RePlugin.install("/sdcard/exam_new.apk"); if (pi != null) { RePlugin.preload(pi); } ``` -------------------------------- ### Inherit RePluginApplication for Host Application Source: https://github.com/qihoo360/replugin/wiki/主程序接入指南 To integrate RePlugin, your host application's Application class should directly inherit from RePluginApplication. This simplifies the setup by automatically handling RePlugin's lifecycle methods. Remember to declare this Application class in your AndroidManifest.xml. ```Java public class MainApplication extends RePluginApplication { } ``` -------------------------------- ### RePlugin API: Plugin Dex Preloading Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Explains the RePlugin.preload() methods, which optimize plugin startup by pre-releasing and caching Dex files without fully launching the plugin. It details both string and PluginInfo parameter overloads and their benefits. ```APIDOC RePlugin.preload(pluginName: String): void - Preloads the Dex of a built-in or external plugin by its name. - Parameters: - pluginName: The name of the plugin to preload (e.g., "exam"). - Behavior: - Releases the plugin's Dex files and caches them in memory. - Does NOT start the plugin, load its Application object, or open its Activity/components. - Primarily used to improve subsequent plugin startup speed. RePlugin.preload(pluginInfo: PluginInfo): void - Preloads the Dex of a plugin using its PluginInfo object. - Parameters: - pluginInfo: The PluginInfo object of the plugin to preload (e.g., obtained from RePlugin.install()). - Behavior: - Same as preload(String), but uses a PluginInfo object. - Best Practices: - Use for frequently accessed or essential built-in plugins. - Can be used in a background thread after an upgrade to prepare the new plugin. ``` -------------------------------- ### Apply RePlugin Host Gradle Plugin and Add Library Dependency Source: https://github.com/qihoo360/replugin/wiki/主程序接入指南 In your app/build.gradle file, apply the replugin-host-gradle plugin and add the replugin-host-lib dependency. The plugin must be applied *after* the android{} block to correctly read the applicationId. This setup enables RePlugin's runtime features and allows for host-specific configurations. ```Gradle android { // ATTENTION!!! Must CONFIG this to accord with Gradle's standard, and avoid some error defaultConfig { applicationId "com.qihoo360.replugin.sample.host" ... } ... } // ATTENTION!!! Must be PLACED AFTER "android{}" to read the applicationId apply plugin: 'replugin-host-gradle' /** * 配置项均为可选配置，默认无需添加 * 更多可选配置项参见replugin-host-gradle的RepluginConfig类 * 可更改配置项参见 自动生成RePluginHostConfig.java */ repluginHostConfig { /** * 是否使用 AppCompat 库 * 不需要个性化配置时，无需添加 */ useAppCompat = true /** * 背景不透明的坑的数量 * 不需要个性化配置时，无需添加 */ countNotTranslucentStandard = 6 countNotTranslucentSingleTop = 2 countNotTranslucentSingleTask = 3 countNotTranslucentSingleInstance = 2 } dependencies { compile 'com.qihoo360.replugin:replugin-host-lib:2.2.4' ... } ``` -------------------------------- ### RePlugin: Host Launching Plugin Activity (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的组件 Demonstrates how the host application can start an activity located within a RePlugin plugin. This is done using `RePlugin.startActivity()` in conjunction with `RePlugin.createIntent()` to specify the target plugin and activity. ```Java RePlugin.startActivity(MainActivity.this, RePlugin.createIntent("demo1", "com.qihoo360.replugin.sample.demo1.MainActivity")); ``` -------------------------------- ### Non-Inheritance RePlugin Application Setup Source: https://github.com/qihoo360/replugin/wiki/主程序接入指南 For advanced scenarios or when direct inheritance of RePluginApplication is not feasible, you can manually integrate RePlugin by calling RePlugin.App methods within your custom Application class's lifecycle callbacks. Ensure these calls are made synchronously on the UI thread, immediately after super.xxx() calls, and correspond one-to-one with the Application lifecycle methods. ```Java public class MainApplication extends Application { @Override protected void attachBaseContext(Context base) { super.attachBaseContext(base); RePlugin.App.attachBaseContext(this); .... } @Override public void onCreate() { super.onCreate(); RePlugin.App.onCreate(); .... } @Override public void onLowMemory() { super.onLowMemory(); /* Not need to be called if your application's minSdkVersion > = 14 */ RePlugin.App.onLowMemory(); .... } @Override public void onTrimMemory(int level) { super.onTrimMemory(level); /* Not need to be called if your application's minSdkVersion > = 14 */ RePlugin.App.onTrimMemory(level); .... } @Override public void onConfigurationChanged(Configuration config) { super.onConfigurationChanged(config); /* Not need to be called if your application's minSdkVersion > = 14 */ RePlugin.App.onConfigurationChanged(config); .... } } ``` -------------------------------- ### Configure RePlugin Signature Verification for Non-Inherited Applications (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Demonstrates how to enable signature verification for applications that do not inherit `RePluginApplication`. A `RePluginConfig` object is created, `setVerifySign()` is called, and then this configuration is passed to `RePlugin.App.attachBaseContext()` during application initialization. ```Java RePluginConfig c = new RePluginConfig(); c.setVerifySign(!BuildConfig.DEBUG); ... RePlugin.App.attachBaseContext(context, c); ``` -------------------------------- ### RePlugin: Host Querying Plugin ContentProvider (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的组件 Shows how the host application can interact with a RePlugin plugin's `ContentProvider`. The example uses `PluginProviderClient.query()`, indicating that other `ContentProvider` operations are available through this client. ```Java PluginProviderClient.query(xxx); ``` -------------------------------- ### RePlugin API for Plugin Information Retrieval Source: https://github.com/qihoo360/replugin/wiki/插件的信息 This section details the RePlugin APIs used to obtain information about installed plugins, check for plugin installation status, and manage plugin updates. It covers methods for fetching current plugin details, listing all installed plugins, and handling pending updates. ```APIDOC RePlugin.getPlugin(pluginName: String) - Description: Retrieves information for a specific plugin by its package name or alias. - Parameters: - pluginName (String): The package name or alias of the plugin. - Returns: PluginInfo object if the plugin is found and installed, null otherwise. - Usage: Can be used to check if a plugin is currently installed. RePlugin.getPluginInfoList() - Description: Retrieves a list of all installed plugins, including built-in ones. - Returns: List containing information for all installed plugins. RePlugin.install(filePath: String) - Description: Installs a plugin from a given file path. - Returns: PluginInfo object upon successful installation, null on failure. PluginInfo.getPendingUpdate() - Description: Retrieves information about a new version of the plugin that has been installed but is not yet active. This method is called on a PluginInfo object representing the currently running plugin. - Returns: PluginInfo object for the pending update, or null if no update is pending for this plugin. ``` -------------------------------- ### Declare Host Application in AndroidManifest.xml Source: https://github.com/qihoo360/replugin/wiki/主程序接入指南 After creating or modifying your host application's Application class, ensure it is correctly declared in the AndroidManifest.xml file using the android:name attribute. This informs the Android system which Application class to instantiate when your app starts. ```XML ``` -------------------------------- ### Configure RePlugin Signature Verification in RePluginApplication (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Example of enabling signature verification by setting `setVerifySign(!BuildConfig.DEBUG)` within the `createConfig()` method of a `RePluginApplication` subclass. This best practice ensures that signature verification is active only in release builds, improving security while allowing easier debugging. ```Java @Override protected RePluginConfig createConfig() { RePluginConfig c = new RePluginConfig(); c.setVerifySign(!BuildConfig.DEBUG); ... return c; } ``` -------------------------------- ### RePlugin: Plugin Calling External Components (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的组件 Demonstrates three methods for a RePlugin plugin to launch activities or components external to itself. This includes using `ComponentName` directly, `RePlugin.createIntent` for quick intent creation, and `RePlugin.startActivity` for a one-line solution. It also shows how to use an action to start an external activity. ```Java // 方法1（最“单品”) Intent intent = new Intent(); intent.setComponent(new ComponentName("demo2", "com.qihoo360.replugin.sample.demo2.databinding.DataBindingActivity")); context.startActivity(intent); // 方法2（快速创建Intent） Intent intent = RePlugin.createIntent("demo2", "com.qihoo360.replugin.sample.demo2.databinding.DataBindingActivity"); context.startActivity(intent); // 方法3（一行搞定） RePlugin.startActivity(v.getContext(), new Intent(), "demo2", "com.qihoo360.replugin.sample.demo2.databinding.DataBindingActivity"); Intent intent = new Intent( "com.qihoo360.replugin.sample.demo2.action.theme_fullscreen_2"); RePlugin.startActivity(v.getContext(), intent, "demo2", null); ``` -------------------------------- ### Apply RePlugin Plugin and Add Library Dependency Source: https://github.com/qihoo360/replugin/wiki/插件接入指南 This snippet applies the 'replugin-plugin-gradle' plugin and adds the 'replugin-plugin-lib' dependency within the 'app/build.gradle' file. This configures the application module to be built as a RePlugin plugin, providing the necessary runtime library. ```groovy apply plugin: 'replugin-plugin-gradle' dependencies { compile 'com.qihoo360.replugin:replugin-plugin-lib:2.2.4' ... } ``` -------------------------------- ### Configure RePlugin Host for AppCompat Support Source: https://github.com/qihoo360/replugin/wiki/主程序接入指南 If your application uses AppCompat, enable AppCompat support in the repluginHostConfig block within your app/build.gradle. Setting useAppCompat = true ensures that RePlugin generates AppCompat-compatible 'pit' activities for plugins, preventing IllegalStateException related to themes. ```Gradle repluginHostConfig { useAppCompat = true } ``` -------------------------------- ### Java: Preload Built-in RePlugin Plugin Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Demonstrates how to explicitly preload a built-in RePlugin plugin by its name. This action prepares the plugin's Dex for quicker access without fully activating the plugin. ```Java RePlugin.preload("exam"); ``` -------------------------------- ### Java Example: Fetching Current and Pending Plugin Info Source: https://github.com/qihoo360/replugin/wiki/插件的信息 This Java code demonstrates how to retrieve the currently running plugin's information using RePlugin.getPlugin() and then check for a pending update using PluginInfo.getPendingUpdate(). This is particularly useful for managing plugin lifecycle during updates without requiring a process restart. ```Java // Fetch "Current Version" plugin. PluginInfo pi = RePlugin.getPluginInfo("exam"); if (pi != null) { // Fetch "New Version" plugin PluginInfo newPi = pi.getPendingUpdate(); if (newPi != null) { ... } else { // No update ... } } ``` -------------------------------- ### Java: Uninstall RePlugin Plugin by Name Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Shows the Java code for uninstalling a RePlugin plugin by providing its unique name. Note that the actual uninstallation may be deferred if the plugin is currently running. ```Java RePlugin.uninstall("exam"); ``` -------------------------------- ### Configure RePlugin Host Gradle for Main Process Plugin Management (Groovy) Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Shows how to configure the `replugin-host-gradle` plugin in `app/build.gradle` to use the main process as the plugin management process. Setting `persistentEnable = false` prevents the creation of an additional persistent process, which can be beneficial for applications sensitive to process count. ```Groovy apply plugin: 'replugin-host-gradle' repluginHostConfig { // ... 其它RePlugin参数 // 设置为“不需要常驻进程” persistentEnable = false } ``` -------------------------------- ### Configure RePlugin Host Activity Pit Counts Source: https://github.com/qihoo360/replugin/wiki/主程序接入指南 Customize the number of non-translucent 'pit' activities for different launch modes (standard, singleTop, singleTask, singleInstance) in the repluginHostConfig block. This allows fine-tuning the host's capacity for hosting plugin activities based on your application's requirements. ```Gradle repluginHostConfig { /** * 背景不透明的坑的数量 */ countNotTranslucentStandard = 6 countNotTranslucentSingleTop = 2 countNotTranslucentSingleTask = 3 countNotTranslucentSingleInstance = 2 } ``` -------------------------------- ### Add RePlugin Host Gradle Dependency Source: https://github.com/qihoo360/replugin/wiki/主程序接入指南 To integrate RePlugin into your Android project, add the replugin-host-gradle plugin as a classpath dependency in your project's root build.gradle file. This plugin is essential for RePlugin's build-time functionalities. ```Gradle buildscript { dependencies { classpath 'com.qihoo360.replugin:replugin-host-gradle:2.2.4' ... } } ``` -------------------------------- ### RePlugin API: Plugin Uninstallation Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Describes the RePlugin.uninstall() method for removing plugins by name. It outlines the method's behavior, including deferred uninstallation for active plugins and the inability to uninstall built-in plugins, along with recommended best practices. ```APIDOC RePlugin.uninstall(pluginName: String): boolean - Uninstalls a plugin by its unique name. - Parameters: - pluginName: The name of the plugin to uninstall (e.g., "exam"). - Returns: True if the uninstall request was recorded, false otherwise. - Behavior: - If the plugin is running, the uninstall request is recorded and executed after all processes using the plugin terminate and restart. - Built-in plugins cannot be uninstalled as they are bundled with the host application. - Best Practices: - Prompt user for confirmation before uninstalling. - If uninstalling a running plugin, inform the user about the required app restart or restart after screen lock. ``` -------------------------------- ### RePlugin Plugin Gradle Tasks Reference Source: https://github.com/qihoo360/replugin/wiki/插件调试 A comprehensive reference for the various Gradle tasks provided by the RePlugin plugin. These tasks facilitate the management of plugin lifecycle within a host application, including installation, uninstallation, running, and debugging. Note that some debugging tasks may require `RePlugin.enableDebugger(base, BuildConfig.DEBUG);` to be enabled in the host application. ```APIDOC rpForceStopHostApp - Description: Forces the host application to stop. rpInstallAndRunPluginDebug / rpInstallAndRunPluginRelease - Description: Installs the plugin into the host application and then runs it. This is a commonly used task. rpInstallPluginDebug / rpInstallPluginRelease - Description: Installs the plugin into the host application without running it. rpRestartHostApp - Description: Restarts the host application. rpRunPluginDebug / rpRunPluginRelease - Description: Runs the plugin. This task will fail if the plugin has not been installed previously. rpStartHostApp - Description: Starts the host application. rpUninstallPluginDebug / rpUninstallPluginRelease - Description: Uninstalls the plugin from the host application. For a complete uninstallation, the rpRestartHostApp task may also need to be executed. ``` -------------------------------- ### Add RePlugin Plugin Gradle Dependency Source: https://github.com/qihoo360/replugin/wiki/插件接入指南 This snippet adds the 'replugin-plugin-gradle' plugin as a classpath dependency in the project's root 'build.gradle' file. This step is crucial for enabling RePlugin's build-time functionalities and transformations required for plugin development. ```groovy buildscript { dependencies { classpath 'com.qihoo360.replugin:replugin-plugin-gradle:2.2.4' ... } } ``` -------------------------------- ### Add Certificate Signature to RePlugin Whitelist (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的管理 Illustrates how to add a valid certificate signature to RePlugin's whitelist using `RePlugin.addCertSignature()`. The parameter is the MD5 hash of the signature certificate, with colons removed. This step is essential for successful signature verification of plugins. ```Java // Add signature to "White List" RePlugin.addCertSignature("379C790B7B726B51AC58E8FCBCFEB586"); ``` -------------------------------- ### RePlugin: Host Binding to Plugin Service (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的组件 Illustrates how the host application can bind to a service provided by a RePlugin plugin. This is accomplished using `PluginServiceClient.bindService()`, which takes an intent created via `RePlugin.createIntent()` and a `ServiceConnection`. ```Java PluginServiceClient.bindService(RePlugin.createIntent( "exam", "AbcService"), mServiceConn); ``` -------------------------------- ### RePlugin Host-Plugin Code Sharing Configuration Source: https://github.com/qihoo360/replugin/wiki/FAQ To enable code sharing between the host application and plugins, configure the plugin to use a provided dependency for shared JARs. Additionally, enable the UseHostClassIfNotFound setting in the host's RePlugin configuration to allow the host to provide classes if they are not found within the plugin, preventing duplicate class loading. ```Gradle dependencies { // Use 'provided' to compile against shared code without bundling it into the plugin provided files('libs/your-shared.jar') } ``` ```APIDOC RePlugin Host Configuration: UseHostClassIfNotFound: boolean - Purpose: When enabled, if a class is not found within the plugin's classpath, RePlugin will attempt to load it from the host application's classpath. - Default: False - Usage: Set to true in the host's RePlugin initialization to facilitate code sharing and avoid class duplication. ``` -------------------------------- ### RePlugin: Host Fetching Plugin Context (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的组件 Explains how the host application can obtain the `Context` of a specific RePlugin plugin. The `RePlugin.fetchContext()` method is used, requiring the plugin's name as a parameter. ```Java Context examContext = RePlugin.fetchContext("exam"); ``` -------------------------------- ### RePlugin: Plugin Obtaining Host Application Context (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的组件 Shows how a RePlugin plugin can retrieve the `Context` of the host application. This is achieved by calling the `RePlugin.getHostContext()` method, allowing plugins to access host resources. ```Java Context hostContext = RePlugin.getHostContext(); ``` -------------------------------- ### RePlugin: Plugin Calling Host Application Components (Java) Source: https://github.com/qihoo360/replugin/wiki/插件的组件 Illustrates how a RePlugin plugin can launch an activity belonging to the host application. The process is similar to standard Android component invocation, requiring the host's package name in the `ComponentName`. ```Java Intent intent = new Intent(); intent.setComponent(new ComponentName("com.qihoo360.replugin.sample.host", "com.qihoo360.replugin.sample.host.MainActivity")); context.startActivity(intent); ``` -------------------------------- ### Apply and Configure RePlugin Plugin Gradle Source: https://github.com/qihoo360/replugin/wiki/插件调试 This Gradle build script block applies the RePlugin plugin and sets its core configuration properties. These properties include the plugin's name, the host application's package ID, and its main launcher activity. This configuration should be placed after the Android plugin configuration in the build.gradle file. ```Gradle apply plugin: 'replugin-plugin-gradle' repluginPluginConfig { pluginName = "demo3" hostApplicationId = "com.qihoo360.replugin.sample.host" hostAppLauncherActivity = "com.qihoo360.replugin.sample.host.MainActivity" } ``` -------------------------------- ### Configure RePlugin Maven Repository in Gradle Source: https://github.com/qihoo360/replugin/blob/dev/README.md This snippet demonstrates how to add the new Maven repository for RePlugin to your Android project's `build.gradle` file. This is necessary to continue using RePlugin after its migration from JCenter. ```Gradle maven {url "http://maven.geelib.360.cn/nexus/repository/replugin/"} ``` -------------------------------- ### Configure RePlugin Plugin Gradle Repository Source: https://github.com/qihoo360/replugin/wiki/插件调试 This Gradle build script block configures the necessary repositories and dependencies to integrate the RePlugin plugin-gradle into an Android project. It specifies JCenter as a repository and adds the plugin's classpath dependency. ```Gradle buildscript { repositories { jcenter() } dependencies { classpath 'com.qihoo360.replugin:replugin-plugin-gradle:2.2.4' } } ``` -------------------------------- ### Declare Plugin Framework Version in AndroidManifest.xml Source: https://github.com/qihoo360/replugin/wiki/插件的信息 To ensure plugin compatibility with the host application's RePlugin framework version, declare the framework version in AndroidManifest.xml. This is typically not required as the default is 4, but can be specified for specific compatibility needs, especially for older plugins running on newer framework versions. ```XML ``` -------------------------------- ### Declare Plugin Protocol Version in AndroidManifest.xml Source: https://github.com/qihoo360/replugin/wiki/插件的信息 To ensure compatibility between plugins and the host application after significant interface changes, declare the plugin protocol version in AndroidManifest.xml. Both 'low' and 'high' versions are currently required and should be equal. This helps manage breaking changes in plugin interfaces. ```XML ``` -------------------------------- ### Declare Plugin Alias in AndroidManifest.xml Source: https://github.com/qihoo360/replugin/wiki/插件的信息 To declare a plugin alias, add a meta-data tag within the plugin's AndroidManifest.xml. This alias provides a shorter, more readable name for the plugin, recommended for frequently used plugins. The alias takes precedence over the filename for built-in plugins. ```XML ``` -------------------------------- ### Resolve Android Fragment ClassCastException in RePlugin Plugins Source: https://github.com/qihoo360/replugin/wiki/FAQ This snippet provides a solution for "Fragment cannot be cast to android.support.v4.app.Fragment" errors, which commonly occur due to support-v4 library version conflicts between the host application and plugins. The approach involves excluding support-v4 from the plugin's dependencies and using a 'provided' dependency for the necessary fragment library, ensuring the host's version is used. ```Gradle configurations { // Exclude support-v4 from all configurations to prevent conflicts all*.exclude group: 'com.android.support', module: 'support-v4' } dependencies { // Use 'provided' for the fragment library (e.g., fragment.jar) // This tells Gradle that the library will be provided by the host at runtime, // avoiding its inclusion in the plugin's APK. provided files('libs/fragment.jar') } ``` === COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.