https://github.com/processing/processing-android-library-template

Processing Android Library Template for Gradle
https://github.com/processing/processing-android-library-template

Last synced: 9 months ago
JSON representation

Processing Android Library Template for Gradle

• Host: GitHub
• URL: https://github.com/processing/processing-android-library-template
• Owner: processing
• Created: 2013-08-14T03:55:04.000Z (over 12 years ago)
• Default Branch: main
• Last Pushed: 2024-06-26T01:46:49.000Z (over 1 year ago)
• Last Synced: 2025-03-27T15:31:02.683Z (9 months ago)
• Language: CSS
• Homepage:
• Size: 589 KB
• Stars: 33
• Watchers: 27
• Forks: 61
• Open Issues: 1
• Metadata Files:
  • Readme: README.md
  • License: license.txt

Awesome Lists containing this project

README

          
These instructions will help you get started with developing a library for Processing Android using Gradle and Android Studio. The steps walk you through three main tasks:

1. Configuring the build properties so that your library can be built and packaged by Gradle.

2. Finding the library files produced by Gradle for use in Processing and redistribution.

3. Setting up the debug project in Android Studio, which allows you to develop and debug your library using Android Studio as the programming environment.

**NOTE:** This template should be used as the starting point for a new library that uses [Android-specific functions](https://android.processing.org/reference/) in the Android mode, or API from the [Android platform](https://developer.android.com/reference/packages). If your library only uses the regular Processing API and does not depend on any desktop-specific functionality or packages, you could use the regular [Processing library template](https://github.com/processing/processing-library-template).

## Prerequisites

The following components must be installed in order to go through the Usage Instructions.

* [Gradle Build Tool](https://gradle.org/) (use version 7.x, this library template is not compatible with Gradle 8+ yet).

* Version 17 of LTS release of the [Adoptium OpenJDK](https://adoptium.net/) (21-LTS or newer not yet supported).

* [Git client](https://git-scm.com/downloads).

* [Android Studio](https://developer.android.com/studio/) version 3.1 or later.

* [Processing 4.2](https://processing.org/download/) or later.

* Android mode for Processing, installed into the PDE using the [Contributions Manager](https://android.processing.org/tutorials/getting_started/index.html).

## Set Up and Compile

1. Download and install Gradle following [these instructions](https://gradle.org/install/).

2. Fork the template repository to use as a starting point.

  * Navigate to https://github.com/processing/processing-android-library-template in your browser.

  * Click the "Fork" button in the top-right of the page.

  * Once your fork is ready, open the new repository's "Settings" by clicking the link in the menu bar on the right.

  * Change the repository name to the name of your library and save your changes.

  * NOTE: GitHub only allows you to fork a project once. If you need to create multiple forks, you can follow these [instructions](http://adrianshort.org/2011/11/08/create-multiple-forks-of-a-github-repo/).

3. Checkout your fork of the template repository using your preferred git client.

4. You can test if the template project can be built with Gradle by open a command line terminal, changing the directory to the ```processing``` subdirectory inside the repository location, and calling ```gradle dist```. This should generarate a distribution folder with several files in it, including ```YourLibrary.zip```. If this is the case, then you are ready to start working with the template to create your own library.

5. Edit the ```processing/resources/build.properties``` file to ensure the following fields are set correctly.

  * **sketchbook.location** is a quasi-optional field that should be set to the path of your Processing sketchbook folder. This field tells the Gradle build to deploy the library to the sketchbook/libraries path defined here (in addition to building a .zip distribution).

  * **android_sdk.location** should contain the path to the Android SDK in your computer. If you have used the Android mode before and let it to automatically download the SDK for you, then it will be inside the sketchbook/android/sdk folder, but here you can set any other location.

  * All of the fields in sections (4) and on are for metadata about your library.

6. Also, make sure to edit the library medatata in ```processing/resources/library.properties``` file.

After having compiled and built your project successfully, you should be able to find your library in Processing's sketchbook folder, examples will be listed in Processing's sketchbook menu. The Gradle build process also generates a zip package of your library for distribution.

## Import into Android Studio

1. Open Android Studio and select the "Import project" menu item in the welcome screen. 

2. Navigate to the location where you checked out the repository in your computer, and select the root folder (not the ```processing``` subfolder).

3. Android Studio should be able to import the project automatically, which includes the library itself and a minimal test app.

**Important note:** The source code of the library is located inside ```library/src``` to follow standard Gradle's project structure. If you make changes there during the debugging using Android Studio, and then use the compilation and packaging instructions above, the resulting library package will include your latest changes in the source code made in Android Studio.