Geminio Android Studio Plugin

Since Android Studio 4.1, support for custom FreeMarker templates (previously added via local folders) has been deprecated. Custom templates can now only be added via IDEA plugins.

Geminio solves this by providing a plugin mechanism that allows you to create, add, and update your own code templates based on the FreeMarker engine without needing to rebuild or redistribute a full IDEA plugin every time a template changes.

The plugin automates the creation of templates and module templates by scanning specified folders for "recipes".

1. Scanning: Upon opening a project in Android Studio, the plugin scans designated folders for recipe definitions.
2. Action Creation: For every discovered template, the plugin automatically generates a new IDE Action (menu item).
3. Menu Integration: These actions are integrated into two locations:
   • The Generate menu (accessible via Cmd + N while inside a code editor).
   • A dedicated group within the New menu (accessible via Cmd + N within the Project View).
4. Execution: When a user selects a template from the menu, the plugin parses the associated recipe.yaml file and executes the defined steps to generate the template or module.

Module templates are specialized templates designed to create new modules with specific folder structures, dependencies, and content. Unlike regular templates, module templates can be executed from any folder, not just from within existing Android modules.

When a module template is used, Geminio performs the following automated tasks:

1. Executes the commands defined in the template recipe.
2. Appends a description of the new module to the settings.gradle file.
3. Automatically adds a dependency on the newly created module to the selected application modules.

Template parameters can use "expressions" to dynamically evaluate values during template generation. Expressions consist of a fixed part and a dynamic part enclosed in ${}.

Rules for expressions:

• The dynamic part ${} is calculated based on the context.
• You can only use parameters that have been declared ABOVE the current expression within the same widgets or globals section.
• Expressions can evaluate to either strings or booleans.

suggest: fragment_${className.classToResource().underscoreToCamelCase()}
visibility: ${includeModule}
availability: true

The widgets section in your recipe configuration defines the user interface parameters (inputs) that will be presented to a user when running a template. You can define three types of parameters: stringParameter, booleanParameter, and suggestParameter. All parameters support expression evaluation for dynamic behavior.

widgets:
  - stringParameter:
      id: className
      name: Class Name
  - booleanParameter:
      id: generateConstructor
      name: Generate Constructor

The recipe section in your configuration allows you to define a sequence of commands that are automatically executed by an Action after a user has provided all required parameters for a template. This is used to automate tasks like dependency management, directory creation, or opening projects immediately after generation.

# Example conceptual structure
recipe:
  - command: addDependencies
    args: ...
  - command: instantiate
    args: ...

If the Android Studio update does not break any internal APIs, follow these steps to release the new version:

1. Create a new branch in the repository.
2. Update the build version: Update the androidStudio(...) value in the root build.gradle.kts.
3. Update the plugin version: In gradle.properties, increment the minor version of hh-geminio (the second digit). Example: change 1.0.0 to 1.1.0.
4. Update CHANGELOG.md: Document the support for the new Android Studio version.
5. Run verification tasks:

   ./gradlew test
   ./gradlew buildPlugin verifyPluginStructure verifyPlugin

6. Submit a PR to the master branch.

To enable built-in features for module creation, add the enableModuleCreationParams value to the predefinedFeatures section in your configuration.

This feature adds two text fields for the new module's name and its main package name. Once enabled, you can use the following special parameters within widgets expressions, globals expressions, and FTL templates:

• __moduleName: The module Gradle path without a leading :, e.g., applicant:core. During file generation, path segments are treated as nested directories.
• __packageName: The packageName of the module added to AndroidManifest.xml. If derived from __moduleName, : characters are replaced with ..
• __formattedModuleName: A formatted module name used as a prefix for classes within the new module.

predefinedFeatures:
  - enableModuleCreationParams

The mkDirs command is used to automatically create a hierarchical folder structure within your module.

To use it, define a list of folder paths in your configuration. Each item in the list represents a root directory, and nested items represent subdirectories. You can use expressions (such as ${srcOut} or ${resOut}) to define paths dynamically based on the project configuration.

mkDirs:
  - ${srcOut}:
      - api
      - di:
          - modules
          - outer
      - ui:
          - presenters

  - ${resOut}:
      - layout
      - drawables
      - values