How jekyllex/jekyllex-android works
Project Type & Purpose
• JekyllEx is a native Android application.
• Its goal is to embed essential tools such as git, ruby, and jekyll so that users can manage a Jekyll blog directly from their Android device.
• The app is standalone and has evolved from an initial GitHub API-based version to now having its own native embedded dependencies.
Analyzing the File Structure
• The project is structured as an Android project (using Gradle with Kotlin DSL – e.g., build.gradle.kts files) with the classic Android directory pattern (src/main, AndroidManifest, res, etc.).
• The “app/src/main/java/xyz/jekyllex” structure shows further separation into packages:
• models: Contains data representations (e.g., File.kt).
• services: Hosting business logic components like ProcessService.kt that likely interact with the embedded dependencies.
• ui: Divided into activities (home, editor, installer, settings, viewer), UI components, and themes.
• utils: Utilitarian functions, constants, commands, and native utilities.
• There is also a webview package under editor, which includes IOBridge and WebViewClient, indicating a specialized handling of web content or integration with native browser components.
• Tests and instrumentation tests are present under “src/test” and “src/androidTest” respectively, signaling good separation of concerns for quality assurance.
• The Gradle scripts and wrapper indicate that the project follows mainstream Android build processes.
Key Components & Their Relationships
• User Interface (UI) Layer:
• Activities: HomeActivity, EditorActivity, SettingsActivity, etc.
• UI Components: Custom dialogs (e.g., CreateFileDialog), app bars (JekyllExAppBar), dropdown menus, and webview components.
• These are the presentation elements that allow users to interact with the app.
• Service/Business Logic Layer:
• ProcessService is the key service component responsible for orchestrating backend logic such as executing embedded commands (likely interacting with git, ruby, or jekyll).
• Other utility classes under "utils" provide shared business logic and constants that various UI and service components depend on.
• Data Models:
• Defined under the “models” package (e.g., File.kt) to represent core data structures, which are manipulated by UI components and services.
• Embedded Dependencies:
• Although the native integrations (git, ruby, jekyll) aren’t part of the Java code itself, they are implied by the README. Indicate these as external modules or runtime components that the ProcessService (or related classes) communicates with.
• Android Framework & Resources:
• AndroidManifest.xml, resource files (drawables, XML, values/themes), and build scripts play a role in application configuration and deployment.
• Build & Deployment:
• Gradle scripts, such as build.gradle.kts and settings.gradle.kts, show how the project is built and configured.
• GitHub workflows under “.github/workflows” give insight into CI/CD and deployment configurations.
• Divide it into layers: Presentation (UI), Business Logic (Services/Utilities), Data Models, and External Dependencies.
• UI Layer: HomeActivity, EditorActivity (with its subcomponents like Editor, Preview, DropdownMenu), Installer, Settings, and Viewer.
• Service Layer: ProcessService and related utilities.
• Model Layer: Data classes from models.
• External / Native Dependencies: Mark components like git, ruby, and jekyll which are integrated at runtime.