StickerCamera: a 2015 Android camera app worth reading as a sample project

What the app does, in the README's own order

The feature list is short and specific: camera capture, photo cropping, photo filters, stickers on a photo where the sticker can be moved, enlarged and rotated, tags in the picture which can also be moved, local saving of finished images, and a gallery view of what you made.

That last clause is the one that frames the project. The README describes the result as more custom views and better framework, and the repository description in Chinese repeats it: a fair number of custom controls and a decent project architecture. This is an author presenting a sample of their Android architecture, not a product with a roadmap.

The repository is written by two people, `ouyezi` and `Skykai521`, and the layout backs up the claim. `ImageViewTouch/` sits at the root as its own module, which is a gesture-handling library for zoom, pan and rotate inside a touch-enabled image view, and the rest of the code lives under `app/`.

The last push was on 2026-06-18, so the repository is not archived, though the copyright notice inside the README is dated 2015 and the screenshots are named after July 2015.

The gesture handling is the part worth stealing

Stickers can be moved, enlarged and rotated, and tags can be moved. That single feature list is where the engineering is, because each of those three operations has to coexist on a canvas where the background photo also pans and zooms. Two-finger scale and rotate on the sticker, one-finger drag to position, and simultaneous background transform, all of which need careful touch dispatch.

That is what `ImageViewTouch/` is for, and having it as a separate top-level directory rather than a package inside `app/` is the structural decision that makes the sample worth reading. The view library is isolated, so its behaviour can be reasoned about without wading through camera and gallery code.

The filter support points to a different approach again. The README credits `Gpu-image` from CyberAgent for image filters, which means filters are GPU shader passes rather than `ColorMatrix` work on a bitmap. On a 2015 codebase that was already the more interesting option, and it is the reason the filters still look the way they do rather than being simple brightness and contrast.

The sticker placement also leans on third-party work rather than reinventing it: the README credits a dedicated `cropimage` library for cropping and the `Aviary-Android-SDK` in its thanks list. Aviary was a commercial photo editing SDK that has since changed hands, so treat that particular entry as history rather than as something to plan around.

Building it: Gradle wrapper, no documented commands

The tree shows a standard Gradle Android project: `gradlew` and `gradlew.bat` at the root, `build.gradle` at the top level and again as a module, `settings.gradle`, `gradle.properties` and a `gradle/` directory holding the wrapper.

./gradlew

The README documents no build commands, no Gradle or Android plugin version, no `compileSdk`, and no `minSdk`. That is a genuine gap for anyone trying to build this today, because an Android project without a declared target SDK version and a wrapper version is likely to need adjusting before it will assemble on a current toolchain.

There is also a `docs/` directory and a `CLAUDE.md` at the root, neither of which the README mentions. Those are the places to look for design notes before concluding that none exist.

What the project does offer is a runnable artifact, and the instruction is unusual enough to be worth repeating exactly: change `screenshot/StickerCamera.zip` to `StickerCamera.apk` and install it. So the demo binary is committed as a zip archive with the wrong extension. That works for trying the app on a device, and it says something about the era this comes from.

A dependency list that dates the project precisely

The thanks section is effectively the dependency manifest, and reading it as a timeline is the fastest way to place this project in time. Butterknife and EventBus are both annotation-processor and event-bus libraries that have since been retired or superseded, which is the clearest signal that this code predates the move to Kotlin coroutines and modern DI.

`Android-Universal-Image-Loader` was the standard image loading library of that period, and it was discontinued. `fastjson` from Alibaba carries a history of security discussion around deserialization of untrusted input. If you copy code from this repository, these are the imports to replace first.

Two entries are less about age than about choice. `PagerSlidingTabStrip` provides the gallery's tabbed pager, and `SystemBarTint` colours the status bar to match the app's theme, which on Android 4.x and 5.x was how you got a coloured status bar at all. Both were the standard answers at the time.

`android-common` from Trinea appears last, which is a general-purpose collection of Android utilities. Reading it as a dependency is a reminder that the app is partly assembled from other people's helper libraries, and the interesting original work is concentrated in the custom views rather than spread evenly across the codebase.

The license needs reading, not guessing

There is an unresolved inconsistency here that affects anyone planning to reuse this code, so it is worth stating plainly rather than summarising. The repository reports no license, which means no license was detected, and there is no LICENSE file in the tree. But the README contains a complete license grant:

Copyright 2015 DaQingkai

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Both facts are true at once and neither settles the other. A license text in a README is a statement of intent by the author, but a repository with no license file is one that automated checks and most tooling will treat as unlicensed. The copyright holder named is DaQingkai, while the contributors are listed as `ouyezi` and `Skykai521`, which is consistent with a Chinese name and a GitHub handle for the same person but is not something to assume on your own.

If you want to reuse code or a design from this project, ask the author. The contact details in the README are a Weibo profile and an email address, and an explicit answer removes the ambiguity entirely.

Two languages, and a README aimed somewhere else

The README is written in English and Chinese side by side, with the Chinese original followed by an English translation and a line crediting the translation tool used. For a 2015 Chinese Android sample that was a reasonable choice, and it means a non-Chinese reader is not locked out.

The top of the README is stranger. Before the project title and before the feature list, there are two lines linking to a different repository, an Android engineer's advanced manual, with the same link text repeated twice. That is not part of the StickerCamera documentation. It reads like the README was edited to promote another project, which is a small thing but a useful reminder that this file is maintained in a loose way rather than as careful documentation.

The screenshots are animated and static images under `screenshot/`, referenced from the README with relative paths, including the `StickerCamera.zip` mentioned above.

Taken together, the documentation is a description of a sample project written for other developers rather than a manual for users. That is consistent with the repository description, which calls it an app with camera, picture cropping, collage sticking and tagging. If you are looking for a photo editor to install today, this is the wrong repository. If you are looking for examples of custom view and gesture code in Java, the `ImageViewTouch/` module and the sticker placement code are the reason to be here.

Editorial conclusion

StickerCamera is worth reading as a piece of Android craft rather than as a product you would ship: the multi-touch handling for placing stickers, the custom view layer and the two-language documentation are all things you can lift into your own work. Shipping it as an app in 2026 is a different story, since it depends on a 2015-era set of libraries and ships its demo APK as a zip file you have to rename yourself. The licensing needs your attention: the repository reports no license while the README carries a full Apache 2.0 grant. Start by opening `app/` and `ImageViewTouch/` in Android Studio, and settle the license question before you copy any code out of it.

Frequently asked questions

Official sources

1. Issues
2. README
3. Skykai521/StickerCamera on GitHub