How to Elevate App Permissions using Shizuku library – Guide
There are several reasons why the permissions granted to your app might not be sufficient. Maybe you, like me, enjoy making nefarious apps that take advantage of the Android API. Some of the APIs I use require specific permissions to be used. Sometimes they can only be accessed by the shell user (ADB) or by the system. However, there is a solution: Shizuku. Shizuku allows you to use Java or Kotlin to call system APIs virtually directly. This article will show you how to to define up Shizuku and use it.
What is Shizuku?
Before we start using Shizuku, it might be helpful to know what exactly it is. If you are familiar with Magisk, then Shizuku is similar. But instead of managing root access, it manages shell access. Shizuku runs its own process with shell-level permissions. How the user activates this process depends on the device, Android version and choice. Shizuku can be enabled via ADB, via wireless ADB on the device (on Android 11 and later), or via root access. Applications that implement Shizuku can then request permission to use this process to perform elevated operations.
Why Shizuku?
While shell-level system access doesn’t allow you to do as much as root, it still provides more access than a normal application would. Also, the way Shizuku works allows you to use Android APIs almost like normal. You don’t need to rely on shell commands (although you can, if you like). If your app needs special permissions that can only be granted through ADB (or with root), Shizuku and Android 11 make a great pair. You can simply use Shizuku to grant special permissions entirely on the device. Even with devices that aren’t on Android 11, Shizuku can be useful. The app provides instructions and scripts for users so you don’t have to.
Integration
Adding Shizuku to your app isn’t the simplest, but it’s not difficult either. Unfortunately, the developer documentation isn’t exactly complete, but this article covers you. Here it is how to integrate Shizuku into your app.
dependencies
The first step is to add Shizuku dependencies. In your module-level build.gradle, add the following to the dependency block. def shizuku_version = ’11 .0.3 ‘ implementation “dev.rikka.shizuku:api:$shizuku_version” implementation “dev.rikka.shizuku: provider: $shizuku_version” Be sure to update the version if necessary. 11.0.3 is the latest at the time of writing.
Provider
For Shizuku to work, you need to add a provider tile to your app manifest. Open AndroidManifest.xml and add the following inside the app tile. android: authorities = ”${applicationId} .shizuku” android: multiprocess = “false” android: enabled = “true” android: exported = “true” android: permission = ”android.permission.INTERACT_ACROSS_USERS_FULL” />
Permission
For authorization, Shizuku uses a runtime permission. We will grant this permission shortly. For now, add it to AndroidManifest.xml inside the manifest block. Now that all of this has been added, the basic integration is complete. Let Gradle do a project sync and proceed to Use.
Use
Checking availability
Before entering how to using Shizuku, let’s talk about how to make sure it’s actually available for use. Before checking whether permission has been granted and before making API calls through Shizuku, you can be sure that these checks and calls will succeed with the following method: Shizuku.pingBinder() If Shizuku is up and running, this will return true. Otherwise it will return false.
Granting permission
Since Shizuku uses a runtime permission, it must be granted to your app before you can do anything with shell access. There are also two versions of the API in circulation, with different forms of granting. This section will show you how to deal with both.
Checking
Before requesting permission, the best thing to do is to check if you already have it. If you do, you can continue with whatever is necessary. Otherwise, you will need to request it before proceeding.
Using APIs
Now that Shizuku is set up and permissions are granted, you can actually start calling APIs using Shizuku. The process here is a little different from what you are used to. Instead of calling getSystemService() and launching to something like WindowManager, you’ll have to use the built-in APIs for them (eg IWindowManager). Shizuku includes a bypass to Android’s hidden API blacklist, so you don’t have to worry about it when using it. if you are curious how to ignore it yourself.
user service
Although the Binder method covers most use cases, there may be times when you need an API that doesn’t have a direct Binder interface. In that case you can use the user service feature in Shizuku. This method works similarly to a normal service on Android. You “start” it, communicate by binding it to a ServiceConnection, and run your logic in the service class. The difference is that you are not using the Android service and everything inside the service runs with ADB permissions. Now there are some limitations. The User Service runs in a completely separate process and user, so you can’t interact with the rest of your app except through your own AIDL and Binders callbacks. Since it’s also not running in a proper app process, some things like binding Android services might not work correctly. This also requires Shizuku version 10 or later. Although most app sources are version 11 currently, you should still include a version check, which will be included in the example.
Defining an AIDL
To get started, you will need to create a new AIDL file. You can do this in Android Studio by right-clicking anything in the Android file view, hovering over the “New” option and choosing the “AIDL” option. Enter the file name (eg “IUserService”) and Android Studio will create a template file for you. If you’re not familiar with how AIDLs work, check your Google documentation. Remove the AIDL model methods and then add a destroy() method with the appropriate ID for Shizuku. It will be called when Shizuku is shutting down the user service and should be used to clean up up any references or continuous logic you have.
Final note
I hope you like the guide How to Elevate App Permissions using Shizuku library. In case if you have any query regards this article you may ask us. Also, please share your love by sharing this article with your friends.
