ShizuStore

ShizuCallRecorder

kitsumed

2.0.0 · GitHub

Download APK
Communication Android 11+ 3 weeks ago GPL-3.0 Recommended
2.9k ShizuStore
79.7k GitHub
2.1k Stars
4 MB Size

More about this app

ShizuCallRecorder empowers ADB through Shizuku to record phone calls on non-rooted device!

ShizuCallRecorder

GitHub Repo stars Download ShizuCallRecorder on Github - All Downloads Stats GitHub Release GitHub Actions Workflow Status

Download ShizuCallRecorder on F-Droid - All Time Downloads Download ShizuCallRecorder on IzzyOnDroid - Yearly Downloads

The first non-root FOSS call recorder app for Android 11+! ShizuCallRecorder empowers ADB through Shizuku to use an advanced list of permissions given to the shell application. It is free, without ads, respect your privacy, and try to apply the best security practices.

This app main focus are Cellular/VoLTE calls, however, we do attempt to support Wifi-Calling and VoIP when possible. Third-party app support is not guaranteed, they may work provided they use Android Telecom.

Features

  • Records both sides of phone calls (incoming and outgoing)
    • Should work even when using Bluetooth or a remote headset
  • Separate uplink and downlink audio inside a stereo recording
  • Cellular/VoLTE capture, with best-effort support for VoIP (and third-party apps) starting Android 14+
  • Security toggles to manage Shizuku on/off state
    • An attempt to reduce the potential attack surface introduced by Shizuku
    • Helps with apps that detect / yells at you when USB Debugging or Shizuku is enabled
  • Automatic call recording option with basic exclusion rules:
    • Ignore anonymous calls
    • Ignore specific contacts
    • Ignore all contacts
  • Multiple codecs available: Opus, AAC, HE-AAC-v1, and more!
  • The app runs only on phone event changes, no persistent background process and notifications

Requirements

  • Android 12 or more recent*.
    • Look at the Android Tested Versions table for more informations on limitations.
  • Shizuku* (we recommend thedjchi fork)
Android Tested Versions I cannot extensively test all of these versions, so issues may arise. This table may change as more testing by other users is done. | Android Version | Supported | Note | |-----------------|-----------|---------------------------------------| | 11 |**Limited**|**[Need Unlocked Screen](https://github.com/Genymobile/scrcpy/blob/3fcc177da5b6b4514d0e8e8d90d7d58d6731eac9/server/src/main/java/com/genymobile/scrcpy/audio/AudioDirectCapture.java#L56-L68)**, ⚠️No VoIP Support| | 12 | **Basic** | ⚠️No VoIP Support (Pixel may work) | | 13 | **Basic** | ⚠️No VoIP Support (Pixel may work) | | 14 | Yes | | | 15 | Yes | | | 16 | Yes | | | 17 | Yes | |

Important

This application makes use of hidden internal Android APIs. As such, it is prone to breaking in new Android releases or due to specific OEM modifications to the source code.

Installation

Please follow the installation and configuration instructions in the our documentation under Installation & Configuration.

You can download the latest version here.

Contributing

Please see the contributing guide.

Translation hosting generously provided by Weblate.

NOTE: By default, Weblate will use your account creation email when making commits to GitHub (to give you credits). This would leak your email address, you can change this behavior in your account settings.

Traduction Stats

License

The software is licensed under the GNU General Public License, version 3 (GPL-3.0). ⚠️ Additional terms under GNU GPL version 3 Section 7 are at the end of the file.

  • This License does not grant any rights in the trademarks, service marks, or logos of any Contributor.
  • As example, the name "ShizuCallRecorder" and com.kitsumed.shizucallrecorder are the property of the copyright holder kitsumed.

I decided to use the GPL-3.0 license, as no other open-source/FOSS call recording app for non-rooted devices on Android 11+ exists yet, and I want to ensure that any potential future alternatives derived from this project remain FOSS.

Disclaimer

Recording phone calls may be subject to complex and varying laws in different countries and jurisdictions. For example, you may need to ensure you have consent from all parties before recording conversations. The developers and contributors are not responsible for any misuse or legal consequences arising from the use of this application. You can learn more on Wikipedia at: Telephone call recording laws.

If you are legally required to inform or ask someone for consent before recording, please note that the application DOES NOT handle this for you. In some cases, certain features, like automatic call recording, may not be legally allowed. It is your responsibility to ensure compliance with applicable laws. This is not legal advice. Please consult a legal professional for guidance regarding your specific situation.

Caution

APPLICATION BEHAVIOR

Due to the evolving Android ecosystem and varying hardware (OEMs), this software is subject to non-deterministic behavior:

  • Concurrent Calls: The app may fail to detect transitions (e.g., while in a call, a second incoming call arrives, or switching between held calls). In these scenarios, the application may continue to record audio into a single continuous file without separate notifications or new notifications prompts for subsequent callers.
  • Filter Logic Limitations: Due to Android privacy-driven restrictions on real-time phone number access, the app may relies, depending on the call detection mode, on fetching deprecated or unstable values. Theses initial check could be used to decide whether to automatically record based on your settings. In cases where we receive the value too late, receive invalid data, or receive no data, the application is likely to consider the call as "anonymous" in its decision process.
  • Unforeseen Failures: Future OS updates, bugs, design choices in the app, or undocumented system behaviors may cause the app to start and/or continue recording, or fail, in a unexpected manner.

USER AWARENESS

Because deterministic behavior of the application cannot be guaranteed, it is your responsibility to:

  1. Ensure the recording behavior and your application settings aligns with your intent and the specific requirements in your jurisdiction.
  2. Monitor the app's behavior on your specific device. If you observe any behavior that does not comply with your local laws, you must immediately cease any activity that constitutes a legal infraction (For example, hanging up the call, deleting the audio files, etc).
Close

How Shizuku is used

Can record phone calls via Shizuku hosted audio capture and grant itself call detection access via `appops` and `cmd role`.

This is an AI-assisted analysis of Shizuku-related usages in the app's public source code. It is best effort, so it may not catch every single usage.

How this app uses Shizuku

Shizuku is used to run a privileged call recording pipeline and to grant the app itself the system access needed for reliable call detection.

  • Record phone calls: during a call the app starts recording in the privileged process and saves it as an audio file in the chosen folder, using the audio source, codec and bit rate selected in settings.
  • Capture call audio sources: the privileged process captures restricted call audio inputs (including uplink, downlink and both sides of the call) that a normal app cannot access, plus system playback audio for internet calls.
  • Enable call detection: the app grants itself the manage ongoing calls operation and companion device roles through privileged commands, so it can reliably detect incoming and outgoing calls.

Android APIs or commands used

  • android.media.AudioRecord
  • MediaRecorder.AudioSource.VOICE_CALL
  • MediaRecorder.AudioSource.VOICE_UPLINK
  • MediaRecorder.AudioSource.VOICE_DOWNLINK
  • MediaRecorder.AudioSource.VOICE_COMMUNICATION
  • android.media.audiopolicy.AudioPolicy
  • AudioManager.registerAudioPolicyStatic
  • AppOpsManager.checkOpNoThrow
  • appops set --user allow
  • cmd role add-role-holder --user

Notable details

Call detection with the phone state mode works with normal permissions, while the InCallService mode requires the privileged grant for the manage ongoing calls operation.

Close

Changelog

What's new for version 2.0.0

🚀 What's Changed

Hey! v2.0.0 is now ready 👀. I have been working on this update for over 2 months, which is why there was no new release and non-major bugs did not get patched.

This release includes a few bug fixes, but the main change is a FULL REFACTORING (#1) of the audio capture logic. The scrcpy-server binary is gone. We now handle audio capture natively with code in our own app. This gives us direct control over PCM audio which this release already makes some use of, and may in the future make even more.

I also want to announce that we now support VoIP / IN_COMMUNICATION type of audio capture starting Android 14. (So most third-party apps and carriers using VoIP or Wi-Fi Calling!). I know I said at multiple places online that it would be starting Android 13, but hum, how do I say this.. Oops, the shell has one permission missing in that version that SPECIFICALLY prevents IN_COMMUNICATION capture and I tested everything except specifically capturing that... 😅

That said, I still want to credit the scrcpy project as I would not have been able to do it without using their code as reference. While I inspired myself and had to make adjustments along with implementing more methods, they still laid out the base work that allowed me to know how it worked and where in AOSP source code I needed to look.

I also want to thank everyone who decided to sponsor me via GitHub Sponsors. ❤️ I'm still amazed I even managed to get 4 monthly sponsors, let alone occasional one-time sponsors.

I will remind you again, but if you use this project often, please consider supporting me. If you do not wish to do it via money, you can still contribute. For example, this new v2.0.0 release is missing translations. You can help on Weblate.

Last minute edit: While updating packages, I was forced to support Android 17. So, Android 17 R1 release is now supported, updated some reflection stuff. That said, if your Shizuku versions does not work with Android 17, then report the issue to your Shizuku repository, not me.

🔭 The future of this project

v2.0.0 is what I wanted v1.x.x to be. A native call recording application. This was my original goal when I first started the project, but at the time, I did not know Android development well, never used Kotlin, Android Studio, read parts of AOSP source code, nor did I know about reflection. My solution was to use the scrcpy-server binary, and little by little, I started learning more and I somehow pulled it off over the last 2 months.

In that regard, I partially see ShizuCallRecorder current position as feature complete / partially in a bug-fix lifecycle. The app is working well for almost all users. There are still more features I wish to add. For example, https://github.com/kitsumed/ShizuCallRecorder/issues/3, which would also cause a rework of how the UI works. Then, that UI rework may cause another plan of mine, https://github.com/kitsumed/ShizuCallRecorder/issues/97 (adding support to connect to ADB ourselves without Shizuku).

I have increasingly wanted to do this because I am not satisfied with the practices of most "updated/popular" Shizuku forks. Their unsafe security and release practices, along with heavy AI/LLM agent usage without a lot of human interaction. We can also add to that their tendencies of mixing tons of other forks features into their own using an LLM, which makes questionable implementations and default configurations.

I am also interested in this because it would allow me to enforce a safer way of making the app work and give me direct control over more failure points. It does, however, worry me, as Shizuku in itself is a complex app, mainly due to the complexity of supporting different manufacturers (OEMs).

For the time being, I continue to recommend thedjchi Shizuku fork, as they offered good security options inside the app, were very open and receptive to security-related requests, and ensured their release CI/process was using the best security they could once notified about it. Sadly, they are currently no longer maintaining the fork, but it is still working as of writing this. I have yet to find another fork which makes me feel comfortable using it, let alone recommend it.

The next new feature you may soon see is a new call detection method based on notifications (https://github.com/kitsumed/ShizuCallRecorder/issues/131), because while we can now start recording third-party apps on Android 14+, not all apps use Android Telecom, which is currently the only way we can detect calls. Notification-based detection could be a workaround for a low number of users / weird apps. Please note, however, that I do not wish to implement advanced support for all kinds of third-party apps, I want my support to be best-effort focused and as generic as possible to prevent maintenance burdens as soon as an X third-party app makes an update.

Last minute edit: If you have some free time, I recommend checking out Android May Soon Restrict On-Device ADB as this may affect the future of this project. Hopefully it won't.

More Details On Changes

Contributors

  • Translations : @oersen @camellan @avishj @Guzleon @kitsumed @Mehrshad0101 and everyone else who have been missed or did not link their github account to weblate.

Full Changelog: https://github.com/kitsumed/ShizuCallRecorder/compare/v1.3.3...v2.0.0 This is a tool, use it responsibly, and follow the law. Read the app disclaimer, it's a one time thing, don't skip it.

GitHub Sponsors

Close

Permissions

14 permissions requested

  • moe.shizuku.manager.permission.API_V23
  • android.permission.POST_NOTIFICATIONS
  • android.permission.READ_PHONE_STATE
  • android.permission.READ_CONTACTS
  • android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
  • android.permission.VIBRATE
  • android.permission.QUERY_ALL_PACKAGES
  • android.permission.SYSTEM_ALERT_WINDOW
  • android.permission.READ_CALL_LOG
  • android.permission.FOREGROUND_SERVICE
  • android.permission.FOREGROUND_SERVICE_SPECIAL_USE
  • android.permission.FOREGROUND_SERVICE_DATA_SYNC
  • android.permission.MANAGE_ONGOING_CALLS
  • com.kitsumed.shizucallrecorder.DYNAMIC_RECEIVER_NOT_EXPORTED_PERMISSION
Close