├── .gitignore ├── .idea ├── .gitignore ├── .name ├── compiler.xml ├── gradle.xml ├── kotlinc.xml ├── misc.xml └── vcs.xml ├── README.md ├── app ├── .gitignore ├── build.gradle ├── libs │ └── flib-release.aar ├── proguard-rules.pro └── src │ ├── androidTest │ └── java │ │ └── com │ │ └── spring │ │ └── musk │ │ └── vappinject │ │ └── ExampleInstrumentedTest.kt │ ├── main │ ├── AndroidManifest.xml │ ├── cpp │ │ ├── CMakeLists.txt │ │ └── native-lib.cpp │ ├── java │ │ └── com │ │ │ └── spring │ │ │ └── musk │ │ │ └── vappinject │ │ │ ├── MainActivity.kt │ │ │ ├── utils │ │ │ └── vAppU.kt │ │ │ └── vApp.kt │ └── res │ │ ├── drawable-v24 │ │ └── ic_launcher_foreground.xml │ │ ├── drawable │ │ └── ic_launcher_background.xml │ │ ├── layout │ │ └── activity_main.xml │ │ ├── mipmap-anydpi-v26 │ │ ├── ic_launcher.xml │ │ └── ic_launcher_round.xml │ │ ├── mipmap-hdpi │ │ ├── ic_launcher.webp │ │ └── ic_launcher_round.webp │ │ ├── mipmap-mdpi │ │ ├── ic_launcher.webp │ │ └── ic_launcher_round.webp │ │ ├── mipmap-xhdpi │ │ ├── ic_launcher.webp │ │ └── ic_launcher_round.webp │ │ ├── mipmap-xxhdpi │ │ ├── ic_launcher.webp │ │ └── ic_launcher_round.webp │ │ ├── mipmap-xxxhdpi │ │ ├── ic_launcher.webp │ │ └── ic_launcher_round.webp │ │ ├── values-night │ │ └── themes.xml │ │ ├── values │ │ ├── colors.xml │ │ ├── strings.xml │ │ └── themes.xml │ │ └── xml │ │ ├── backup_rules.xml │ │ └── data_extraction_rules.xml │ └── test │ └── java │ └── com │ └── spring │ └── musk │ └── vappinject │ └── ExampleUnitTest.kt ├── build.gradle ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle /.gitignore: -------------------------------------------------------------------------------- 1 | *.iml 2 | .gradle 3 | /local.properties 4 | /.idea/caches 5 | /.idea/libraries 6 | /.idea/modules.xml 7 | /.idea/workspace.xml 8 | /.idea/navEditor.xml 9 | /.idea/assetWizardSettings.xml 10 | .DS_Store 11 | /build 12 | /captures 13 | .externalNativeBuild 14 | .cxx 15 | local.properties 16 | -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | -------------------------------------------------------------------------------- /.idea/.name: -------------------------------------------------------------------------------- 1 | vApp-Inject -------------------------------------------------------------------------------- /.idea/compiler.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/gradle.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 18 | 19 | -------------------------------------------------------------------------------- /.idea/kotlinc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 6 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## vApp-Inject 2 | 3 | vApp-Inject is an Android application project designed to provide users with the ability to run Android games and apps independently within it. It offers a seamless environment for running Android applications on various platforms. 4 | 5 | ### Features 6 | 7 | - **Isolated Environment**: Run Android games and apps within a self-contained virtual environment. 8 | - **Automatic OBB Import**: Automatically import OBB files when importing games, ensuring a seamless gameplay experience. 9 | - **Enhanced Libraries**: Utilizes modern Android libraries for improved performance and compatibility. 10 | 11 | ### Dependencies 12 | 13 | vApp-Inject uses the following dependencies: 14 | 15 | - `androidx.core:core-ktx:1.13.0` 16 | - `androidx.appcompat:appcompat:1.6.1` 17 | - `com.google.android.material:material:1.11.0` 18 | - `androidx.constraintlayout:constraintlayout:2.1.4` 19 | - `junit:junit:4.13.2` (for testing) 20 | - `androidx.test.ext:junit:1.1.5` (for testing) 21 | - `androidx.test.espresso:espresso-core:3.5.1` (for testing) 22 | - `com.tencent:mmkv-static:1.2.10` 23 | 24 | ### Installation 25 | 26 | To use vApp-Inject in your Android project, follow these steps: 27 | 28 | 1. Download or Clone the vApp-Inject project from [GitHub](https://github.com/springmusk026/vApp-Inject). 29 | 30 | ### Usage 31 | 32 | Once integrated, you can use vApp-Inject to run Android games and apps within your application. Ensure that your application meets the necessary requirements and permissions for running within the vApp-Inject environment. 33 | 34 | ### Contributing 35 | 36 | Contributions to vApp-Inject are welcome! If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request on the [GitHub repository](https://github.com/springmusk026/vApp-Inject). 37 | 38 | ### License 39 | 40 | This project is licensed under the [MIT License](LICENSE). Feel free to use, modify, and distribute this software as per the terms of the license. 41 | 42 | ### Support 43 | 44 | For any questions or support related to vApp-Inject, you can reach out to the project maintainers or community through the GitHub repository's issue tracker. 45 | 46 | ### External Libraries 47 | Plugin file from [SpaceCore Releases](https://github.com/FSpaceCore/SpaceCore/releases/) 48 | 49 | --- 50 | 51 | **vApp-Inject** is developed and maintained by [Spring Musk](https://github.com/springmusk026) and contributors. We hope it enhances your Android development experience! -------------------------------------------------------------------------------- /app/.gitignore: -------------------------------------------------------------------------------- 1 | /build -------------------------------------------------------------------------------- /app/build.gradle: -------------------------------------------------------------------------------- 1 | plugins { 2 | id 'com.android.application' 3 | id 'org.jetbrains.kotlin.android' 4 | } 5 | 6 | android { 7 | namespace 'com.spring.musk.vappinject' 8 | compileSdk 34 9 | 10 | defaultConfig { 11 | applicationId "com.spring.musk.vappinject" 12 | minSdk 24 13 | targetSdk 34 14 | versionCode 1 15 | versionName "1.0" 16 | 17 | testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" 18 | externalNativeBuild { 19 | ndk { 20 | abiFilters "arm64-v8a" 21 | } 22 | } 23 | } 24 | 25 | buildTypes { 26 | release { 27 | minifyEnabled false 28 | proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' 29 | } 30 | } 31 | compileOptions { 32 | sourceCompatibility JavaVersion.VERSION_1_8 33 | targetCompatibility JavaVersion.VERSION_1_8 34 | } 35 | kotlinOptions { 36 | jvmTarget = '1.8' 37 | } 38 | externalNativeBuild { 39 | cmake { 40 | path file('src/main/cpp/CMakeLists.txt') 41 | version '3.22.1' 42 | } 43 | } 44 | buildFeatures { 45 | viewBinding true 46 | } 47 | } 48 | 49 | dependencies { 50 | 51 | implementation fileTree(dir: "libs", include: ["*.jar", "*.aar"]) 52 | 53 | implementation 'androidx.core:core-ktx:1.13.0' 54 | implementation 'androidx.appcompat:appcompat:1.6.1' 55 | implementation 'com.google.android.material:material:1.11.0' 56 | implementation 'androidx.constraintlayout:constraintlayout:2.1.4' 57 | testImplementation 'junit:junit:4.13.2' 58 | androidTestImplementation 'androidx.test.ext:junit:1.1.5' 59 | androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1' 60 | 61 | implementation("com.tencent:mmkv-static:1.2.10") 62 | } -------------------------------------------------------------------------------- /app/libs/flib-release.aar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/springmusk026/vApp-Inject/c6a8fb68f74622ccc0ba698690520c9c5ca9d7d7/app/libs/flib-release.aar -------------------------------------------------------------------------------- /app/proguard-rules.pro: -------------------------------------------------------------------------------- 1 | # Add project specific ProGuard rules here. 2 | # You can control the set of applied configuration files using the 3 | # proguardFiles setting in build.gradle. 4 | # 5 | # For more details, see 6 | # http://developer.android.com/guide/developing/tools/proguard.html 7 | 8 | # If your project uses WebView with JS, uncomment the following 9 | # and specify the fully qualified class name to the JavaScript interface 10 | # class: 11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview { 12 | # public *; 13 | #} 14 | 15 | # Uncomment this to preserve the line number information for 16 | # debugging stack traces. 17 | #-keepattributes SourceFile,LineNumberTable 18 | 19 | # If you keep the line number information, uncomment this to 20 | # hide the original source file name. 21 | #-renamesourcefileattribute SourceFile -------------------------------------------------------------------------------- /app/src/androidTest/java/com/spring/musk/vappinject/ExampleInstrumentedTest.kt: -------------------------------------------------------------------------------- 1 | package com.spring.musk.vappinject 2 | 3 | import androidx.test.platform.app.InstrumentationRegistry 4 | import androidx.test.ext.junit.runners.AndroidJUnit4 5 | 6 | import org.junit.Test 7 | import org.junit.runner.RunWith 8 | 9 | import org.junit.Assert.* 10 | 11 | /** 12 | * Instrumented test, which will execute on an Android device. 13 | * 14 | * See [testing documentation](http://d.android.com/tools/testing). 15 | */ 16 | @RunWith(AndroidJUnit4::class) 17 | class ExampleInstrumentedTest { 18 | @Test 19 | fun useAppContext() { 20 | // Context of the app under test. 21 | val appContext = InstrumentationRegistry.getInstrumentation().targetContext 22 | assertEquals("com.spring.musk.vappinject", appContext.packageName) 23 | } 24 | } -------------------------------------------------------------------------------- /app/src/main/AndroidManifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 4 | 5 | 7 | 8 | 9 | 20 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /app/src/main/cpp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # For more information about using CMake with Android Studio, read the 2 | # documentation: https://d.android.com/studio/projects/add-native-code.html 3 | 4 | # Sets the minimum version of CMake required to build the native library. 5 | 6 | cmake_minimum_required(VERSION 3.22.1) 7 | 8 | # Declares and names the project. 9 | 10 | project("crashlog") 11 | 12 | # Creates and names a library, sets it as either STATIC 13 | # or SHARED, and provides the relative paths to its source code. 14 | # You can define multiple libraries, and CMake builds them for you. 15 | # Gradle automatically packages shared libraries with your APK. 16 | 17 | add_library( # Sets the name of the library. 18 | crashlog 19 | 20 | # Sets the library as a shared library. 21 | SHARED 22 | 23 | # Provides a relative path to your source file(s). 24 | native-lib.cpp) 25 | 26 | # Searches for a specified prebuilt library and stores the path as a 27 | # variable. Because CMake includes system libraries in the search path by 28 | # default, you only need to specify the name of the public NDK library 29 | # you want to add. CMake verifies that the library exists before 30 | # completing its build. 31 | 32 | find_library( # Sets the name of the path variable. 33 | log-lib 34 | 35 | # Specifies the name of the NDK library that 36 | # you want CMake to locate. 37 | log) 38 | 39 | # Specifies libraries CMake should link to your target library. You 40 | # can link multiple libraries, such as libraries you define in this 41 | # build script, prebuilt third-party libraries, or system libraries. 42 | 43 | target_link_libraries( # Specifies the target library. 44 | crashlog 45 | 46 | # Links the target library to the log library 47 | # included in the NDK. 48 | ${log-lib}) -------------------------------------------------------------------------------- /app/src/main/cpp/native-lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /*you can use cheat codes from here*/ 5 | extern "C" JNIEXPORT jstring JNICALL 6 | Java_com_spring_musk_vappinject_MainActivity_stringFromJNI( 7 | JNIEnv* env, 8 | jobject /* this */) { 9 | std::string hello = "Hello from C++"; 10 | return env->NewStringUTF(hello.c_str()); 11 | } -------------------------------------------------------------------------------- /app/src/main/java/com/spring/musk/vappinject/MainActivity.kt: -------------------------------------------------------------------------------- 1 | package com.spring.musk.vappinject 2 | 3 | import android.Manifest 4 | import android.app.Activity 5 | import android.content.Intent 6 | import android.content.pm.PackageManager 7 | import android.net.Uri 8 | import android.os.Build 9 | import android.os.Bundle 10 | import android.provider.Settings 11 | import android.view.View 12 | import androidx.appcompat.app.AppCompatActivity 13 | import androidx.core.app.ActivityCompat 14 | import androidx.core.content.ContextCompat 15 | import com.fvbox.lib.FCore 16 | import com.google.android.material.dialog.MaterialAlertDialogBuilder 17 | import com.spring.musk.vappinject.databinding.ActivityMainBinding 18 | import com.spring.musk.vappinject.utils.vAppU 19 | 20 | class MainActivity : AppCompatActivity() { 21 | 22 | private lateinit var binding: ActivityMainBinding 23 | 24 | override fun onCreate(savedInstanceState: Bundle?) { 25 | super.onCreate(savedInstanceState) 26 | binding = ActivityMainBinding.inflate(layoutInflater) 27 | setContentView(binding.root) 28 | 29 | checkPermissionsAndProceed() 30 | 31 | } 32 | 33 | private fun checkPermissionsAndProceed() { 34 | val filePermissionGranted = isFilePermissionGranted() 35 | val installPermissionGranted = isInstallPermissionGranted() 36 | 37 | if (filePermissionGranted && installPermissionGranted) { 38 | // Proceed with your logic after both permissions are granted 39 | proceedAfterPermissions() 40 | } else { 41 | if (!installPermissionGranted) { 42 | requestInstallPermission() 43 | } 44 | if (!filePermissionGranted) { 45 | requestFilePermission() 46 | } 47 | } 48 | } 49 | 50 | private fun isInstallPermissionGranted(): Boolean { 51 | return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { 52 | packageManager.canRequestPackageInstalls() 53 | } else { 54 | true // Permissions are not required for older versions 55 | } 56 | } 57 | 58 | private fun isFilePermissionGranted(): Boolean { 59 | return ContextCompat.checkSelfPermission( 60 | this, 61 | Manifest.permission.WRITE_EXTERNAL_STORAGE 62 | ) == PackageManager.PERMISSION_GRANTED 63 | } 64 | 65 | private fun requestInstallPermission() { 66 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { 67 | val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES) 68 | intent.data = Uri.parse("package:$packageName") 69 | startActivityForResult(intent, INSTALL_PERMISSION_REQUEST_CODE) 70 | } 71 | } 72 | 73 | private fun requestFilePermission() { 74 | ActivityCompat.requestPermissions( 75 | this, 76 | arrayOf(Manifest.permission.WRITE_EXTERNAL_STORAGE), 77 | FILE_PERMISSION_REQUEST_CODE 78 | ) 79 | } 80 | 81 | override fun onRequestPermissionsResult( 82 | requestCode: Int, 83 | permissions: Array, 84 | grantResults: IntArray 85 | ) { 86 | super.onRequestPermissionsResult(requestCode, permissions, grantResults) 87 | if (requestCode == FILE_PERMISSION_REQUEST_CODE && grantResults.isNotEmpty() && 88 | grantResults[0] == PackageManager.PERMISSION_GRANTED 89 | ) { 90 | // Check permissions again after file permission is granted 91 | checkPermissionsAndProceed() 92 | } 93 | } 94 | 95 | private fun StartApp(){ 96 | binding.launchgame.visibility = View.VISIBLE 97 | binding.launchgame.setOnClickListener { 98 | FCore.get().launchApk(PACKAGE_NAME, USER_ID) 99 | } 100 | } 101 | private fun proceedAfterPermissions() { 102 | if (isPackageInstalledWithSameArch(PACKAGE_NAME)) { 103 | if (!FCore.get().isInstalled(PACKAGE_NAME, USER_ID)) { 104 | FCore.get().installPackageAsUser(PACKAGE_NAME, USER_ID) 105 | } 106 | if(vAppU.isinternalobb(this@MainActivity, PACKAGE_NAME)){ 107 | return StartApp() 108 | } 109 | vAppU.copyobb(PACKAGE_NAME, this@MainActivity) { 110 | showDialog( 111 | title = "Successful", 112 | message = "Setup Successful, Restart app to continue.", 113 | dismissOnClick = false 114 | ) 115 | } 116 | } else { 117 | showDialog( 118 | title = "Error", 119 | message = "Please install the $PACKAGE_NAME first." 120 | ) 121 | } 122 | } 123 | private fun isPackageInstalledWithSameArch(packageName: String): Boolean { 124 | return try { 125 | val targetAppInfo = packageManager.getApplicationInfo(packageName, 0) 126 | val currentAppInfo = packageManager.getApplicationInfo(packageName, PackageManager.GET_SHARED_LIBRARY_FILES) 127 | 128 | val targetAppAbi = getAbiFromNativeLibraryDir(targetAppInfo.nativeLibraryDir) 129 | val currentAppAbi = getAbiFromNativeLibraryDir(currentAppInfo.nativeLibraryDir) 130 | 131 | targetAppAbi == currentAppAbi 132 | } catch (e: PackageManager.NameNotFoundException) { 133 | false 134 | } 135 | } 136 | 137 | private fun getAbiFromNativeLibraryDir(nativeLibraryDir: String): String { 138 | val supportedAbis = Build.SUPPORTED_ABIS 139 | for (abi in supportedAbis) { 140 | if (nativeLibraryDir.contains(abi)) { 141 | return abi 142 | } 143 | } 144 | return "" 145 | } 146 | 147 | private fun showDialog( 148 | title: String? = null, 149 | message: String? = null, 150 | dismissOnClick: Boolean = true 151 | ) { 152 | MaterialAlertDialogBuilder(this).apply { 153 | title?.let { 154 | setTitle(it) 155 | } 156 | message?.let { setMessage(it) } 157 | setPositiveButton("OK") { dialog, _ -> 158 | dialog.dismiss() 159 | if (dismissOnClick) { 160 | finish() 161 | } 162 | } 163 | setCancelable(false) 164 | .show() 165 | } 166 | } 167 | 168 | companion object { 169 | private const val FILE_PERMISSION_REQUEST_CODE = 1002 170 | private const val INSTALL_PERMISSION_REQUEST_CODE = 1001 171 | val USER_ID = 0 // the user id 172 | val PACKAGE_NAME = "com.dts.freefireth" //the package name of app you want to run in vapp 173 | } 174 | } 175 | -------------------------------------------------------------------------------- /app/src/main/java/com/spring/musk/vappinject/utils/vAppU.kt: -------------------------------------------------------------------------------- 1 | package com.spring.musk.vappinject.utils 2 | 3 | import android.Manifest 4 | import android.app.Activity 5 | import android.content.Context 6 | import android.content.pm.PackageManager 7 | import androidx.core.app.ActivityCompat 8 | import androidx.core.content.ContextCompat 9 | import kotlinx.coroutines.CoroutineScope 10 | import kotlinx.coroutines.Dispatchers 11 | import kotlinx.coroutines.launch 12 | import kotlinx.coroutines.runBlocking 13 | import java.io.File 14 | import java.io.FileInputStream 15 | import java.io.FileOutputStream 16 | import java.io.IOException 17 | 18 | class vAppU { 19 | 20 | 21 | companion object { 22 | 23 | 24 | fun haveFilePermission(activity: Activity) { 25 | val filePermission = Manifest.permission.WRITE_EXTERNAL_STORAGE 26 | if (ContextCompat.checkSelfPermission( 27 | activity, 28 | filePermission 29 | ) != PackageManager.PERMISSION_GRANTED 30 | ) { 31 | ActivityCompat.requestPermissions(activity, arrayOf(filePermission), 1002) 32 | } 33 | } 34 | 35 | fun isinternalobb(context: Context, packagename: String): Boolean { 36 | val internaldatadir = context.dataDir.absolutePath 37 | val obbpath = File("${internaldatadir}/storage/emulated/0/Android/obb/$packagename") 38 | return runBlocking { 39 | if (!obbpath.exists()) { 40 | obbpath.mkdirs() 41 | } 42 | 43 | val thisisobb = obbpath.listFiles { file -> 44 | file.isFile && file.name.endsWith(".obb", ignoreCase = true) 45 | } 46 | 47 | thisisobb?.forEach { obb -> 48 | return@runBlocking true 49 | } 50 | return@runBlocking false 51 | } 52 | } 53 | 54 | public fun isexternalobb(packagename: String): Boolean { 55 | val obbpathsource = File("/storage/emulated/0/Android/obb/$packagename") 56 | return runBlocking { 57 | if (obbpathsource != null) { 58 | if (!obbpathsource.exists()) { 59 | obbpathsource.mkdirs() 60 | } 61 | } 62 | val thisisobb2 = obbpathsource.listFiles { file -> 63 | file.isFile && file.name.endsWith(".obb", ignoreCase = true) 64 | } 65 | thisisobb2?.forEach { obb -> 66 | return@runBlocking true 67 | } 68 | return@runBlocking false 69 | } 70 | } 71 | 72 | public fun copyobb( 73 | packagename: String, 74 | context: Context, 75 | onFailed: () -> Unit 76 | ) { 77 | runBlocking { 78 | val internal = isinternalobb(context, packagename) 79 | val external = isexternalobb(packagename) 80 | if (external) { 81 | if (internal) { 82 | return@runBlocking 83 | } else { 84 | val sourceobbdir = File("/storage/emulated/0/Android/obb/$packagename") 85 | val internaldatadir = context.dataDir.absolutePath 86 | val destinationpath = 87 | File("${internaldatadir}/storage/emulated/0/Android/obb/$packagename") 88 | val getobb = sourceobbdir.listFiles { file -> 89 | file.isFile && file.name.endsWith(".obb", ignoreCase = true) 90 | } 91 | var obbname: File? = null 92 | getobb?.forEach { 93 | obbname = it 94 | } 95 | if (!destinationpath.exists()) { 96 | destinationpath.mkdirs() 97 | } 98 | val destFile = obbname?.name?.let { 99 | File(destinationpath, it) 100 | } 101 | CoroutineScope(Dispatchers.IO).launch { 102 | try { 103 | val input = FileInputStream(obbname) 104 | val output = FileOutputStream(destFile) 105 | val buffer = ByteArray(1024) 106 | var lenth: Int 107 | while (input.read(buffer).also { 108 | lenth = it 109 | } > 0) { 110 | output.write(buffer, 0, lenth) 111 | } 112 | input.close() 113 | output.close() 114 | } catch (err: IOException) { 115 | err.printStackTrace() 116 | } 117 | } 118 | } 119 | } else { 120 | onFailed() 121 | } 122 | } 123 | } 124 | } 125 | } -------------------------------------------------------------------------------- /app/src/main/java/com/spring/musk/vappinject/vApp.kt: -------------------------------------------------------------------------------- 1 | package com.spring.musk.vappinject 2 | 3 | import android.app.Application 4 | import android.content.Context 5 | import com.fvbox.lib.FCore 6 | 7 | class vApp : Application() { 8 | 9 | override fun attachBaseContext(base: Context?) { 10 | super.attachBaseContext(base) 11 | FCore.get().init(this,true) 12 | } 13 | 14 | override fun onCreate() { 15 | super.onCreate() 16 | if(FCore.isClient()) { 17 | return 18 | } 19 | 20 | FCore.get().setHidePath(true) 21 | FCore.get().setHideRoot(true) 22 | FCore.get().setHideVPN(true) 23 | 24 | } 25 | } -------------------------------------------------------------------------------- /app/src/main/res/drawable-v24/ic_launcher_foreground.xml: -------------------------------------------------------------------------------- 1 | 7 | 8 | 9 | 15 | 18 | 21 | 22 | 23 | 24 | 30 | -------------------------------------------------------------------------------- /app/src/main/res/drawable/ic_launcher_background.xml: -------------------------------------------------------------------------------- 1 | 2 | 7 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 | 55 | 60 | 65 | 70 | 75 | 80 | 85 | 90 | 95 | 100 | 105 | 110 | 115 | 120 | 125 | 130 | 135 | 140 | 145 | 150 | 155 | 160 | 165 | 170 | 171 | -------------------------------------------------------------------------------- /app/src/main/res/layout/activity_main.xml: -------------------------------------------------------------------------------- 1 | 2 | 8 | 9 |