Forem: Harsh

How to setup Void IDE in Linux

Harsh — Sun, 18 May 2025 07:53:47 +0000

What Is Void IDE?

Void IDE is an open-source alternative to Cursor, licensed under Apache 2.0 and hosted on GitHub. It was born as a fork of the VS Code codebase, retaining full extension and theme compatibility so you can migrate seamlessly. Void ships with Agent Mode (full read/write file operations), Gather Mode (read-only code exploration), and standard AI-powered completions—all locally controlled.

Prerequisites

Before installing Void IDE, make sure you have the following:

Ubuntu 18.04+ (Desktop or Server).
A user with sudo privileges.
200 MB of free disk space for the IDE itself.
Ollama installed and running locally for LLM hosting:

Install via Homebrew:
```
 brew install ollama
```

Or via the official Linux script:

 curl https://ollama.com/install.sh | sh

Verify and pull a model (e.g., llama2):

 ollama pull llama2
 ollama run llama2 --prompt "Hello"

Ensure the Ollama daemon is running:
```
 ollama daemon start
```

Quick Install on Ubuntu

Download the latest Linux .deb from GitHub Releases (e.g. void_1.99.30034_amd64.deb).

Download Link: https://github.com/voideditor/binaries/releases

Install with APT to auto-resolve dependencies:

   cd ~/Downloads
   sudo apt update
   sudo apt install ./void_1.99.30034_amd64.deb

Void vs. Cursor AI: Pros & Cons

	Void IDE	Cursor AI
Source & Privacy	Fully open source under Apache 2.0—audit the code, self-host your models, and keep all data in your infrastructure.	Proprietary; code and prompts typically go through Cursor’s managed service unless you opt—and pay—for enterprise hosting.
Model Flexibility	Connect any LLM—open-source or commercial—without vendor lock-in.	Provides a curated frontier-model backend with SLA guarantees but limited ability to swap in your own LLMs.
Cost	Free to use, no subscription or usage fees.	Subscription-based; costs scale with usage and seats, potentially expensive for heavy users.
Ecosystem	Leverages the vast VS Code extension marketplace, but smaller community around AI-specific plugins.	Rich, first-party integrations (Composer, diff viewers, built-in agents) with deeper AI features out of the box.
Stability & Polish	Early-stage UX; occasional rough edges and less extensive documentation.	Mature, polished UI and streamlined onboarding optimized for rapid productivity.
Community	Community-driven roadmaps; rapid iteration on GitHub with weekly contributor meetups.	Backed by Anysphere with deep pockets (recent \$9 bn valuation); robust support but less direct community control.

Windows is Easy just install MSI package from github release and one click install.

Happy Coding 🤘

Android Automotive: Customizing System Bars with Runtime Resource Overlays

Harsh — Thu, 19 Dec 2024 06:18:41 +0000

As Android Automotive continues to evolve, automotive manufacturers often need to customize their vehicle's user interface to match their brand identity and user experience requirements. One crucial aspect of this customization is the system bar configuration. In this article, we'll explore how to customize system bars using Runtime Resource Overlays (RRO) in Android Automotive.

Understanding System Bars in Android Automotive

Before diving into the customization process, let's understand what system bars are in the context of Android Automotive. Unlike regular Android devices that typically have a status bar at the top and navigation bar at the bottom, Android Automotive supports up to four system bars:

Top System Bar
Left System Bar
Right System Bar
Bottom System Bar

Each of these bars can serve different purposes and can be configured independently to create a unified user experience that matches your vehicle's interface requirements.

Runtime Resource Overlays (RRO): The Customization Tool

Runtime Resource Overlays provide a powerful mechanism to modify resources at runtime without changing the original application's code. This is particularly useful for system UI customization in Android Automotive, as it allows manufacturers to:

Enable or disable specific system bars
Configure the type and behavior of each bar
Set z-order for overlapping bars
Customize the orientation of status icons
Control how bars behave during immersive mode

Implementation Guide

Let's walk through the process of creating an RRO to customize system bars.

Step 1: Project Structure

First, create a project structure that looks like this:

.
├── Android.bp
├── AndroidManifest.xml
└── res
    ├── values
    │   └── config.xml
    └── xml
        └── car_sysui_overlays.xml

Step 2: Define the Build Configuration

Create an Android.bp file to define your RRO package:

package {
    default_applicable_licenses: ["Android-Apache-2.0"],
}

runtime_resource_overlay {
    name: "CarSystemUICustomRRO",
    resource_dirs: ["res"],
    manifest: "AndroidManifest.xml",
    system_ext_specific: true
}

Step 3: Configure the Manifest

Create an AndroidManifest.xml that targets SystemUI:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.android.systemui.rro.custom">
    <overlay
        android:targetPackage="com.android.systemui"
        android:isStatic="true"
        android:resourcesMap="@xml/car_sysui_overlays"
    />
</manifest>

Step 4: Define System Bar Configuration

Create config.xml in the res/values directory to define your system bar configuration:

<resources>
    <!-- Enable/disable system bars -->
    <bool name="config_enableTopSystemBar">false</bool>
    <bool name="config_enableLeftSystemBar">true</bool>
    <bool name="config_enableRightSystemBar">false</bool>
    <bool name="config_enableBottomSystemBar">false</bool>

    <!-- Define system bar types -->
    <!-- STATUS_BAR = 0 -->
    <!-- NAVIGATION_BAR = 1 -->
    <!-- STATUS_BAR_EXTRA = 2 -->
    <!-- NAVIGATION_BAR_EXTRA = 3 -->
    <integer name="config_leftSystemBarType">1</integer>

    <!-- Configure z-order -->
    <integer name="config_leftSystemBarZOrder">10</integer>

    <!-- Set status icon orientation (0 = horizontal, 1 = vertical) -->
    <integer name="config_statusIconLayoutOrientation">1</integer>
</resources>

Step 5: Create Resource Mapping

Create car_sysui_overlays.xml in the res/xml directory to map your configurations:

<overlay>
    <item
        target="bool/config_enableLeftSystemBar"
        value="@bool/config_enableLeftSystemBar" />
    <item
        target="integer/config_leftSystemBarType"
        value="@integer/config_leftSystemBarType" />
    <item
        target="integer/config_leftSystemBarZOrder"
        value="@integer/config_leftSystemBarZOrder" />
    <item
        target="integer/config_statusIconLayoutOrientation"
        value="@integer/config_statusIconLayoutOrientation" />
</overlay>

Understanding Key Configuration Options

Let's break down some important configuration options:

System Bar Types

STATUS_BAR (0): Displays status information like time, battery, etc.
NAVIGATION_BAR (1): Contains navigation controls
STATUS_BAR_EXTRA (2): Additional status information
NAVIGATION_BAR_EXTRA (3): Additional navigation controls

Z-Order Configuration

The z-order configuration is crucial when you have multiple system bars that might overlap:

Values below 10 place the bar behind Heads-Up Notifications (HUNs)
Values 10 and above place the bar in front of HUNs
Overlapping bars must have different z-orders to prevent runtime exceptions

Immersive Mode Behavior

You can control how system bars behave during immersive mode using config_systemBarPersistency:

0 (non_immersive): Show all system bars
1 (immersive): Hide all bars
2 (immersive_with_nav): Show navigation bar but hide status bar

Best Practices and Considerations

Consistency: Ensure your system bar configuration aligns with your overall UI/UX strategy.
Performance: Remember that each enabled system bar consumes system resources and screen real estate.
Testing: Thoroughly test your configuration across different screen sizes and orientations.
Z-Order Conflicts: Always assign unique z-orders to overlapping system bars to prevent runtime exceptions.
Icon Orientation: Choose the icon orientation that best matches your system bar placement (vertical for side bars, horizontal for top/bottom bars).

Conclusion

Runtime Resource Overlays provide a powerful and flexible way to customize system bars in Android Automotive. By following this guide and understanding the various configuration options, you can create a unique and cohesive user interface that meets your specific requirements while maintaining system stability and performance.

Remember that system bar customization is just one aspect of creating a great automotive UI. Consider how your system bar configuration integrates with other UI elements and contributes to the overall user experience of your vehicle's infotainment system.

Example Implementation

https://github.com/hpnightowl/SystemUISystembarsAAOS

Adding Custom Vendor Packages to Android Source Code: A Complete Guide

Harsh — Sun, 01 Dec 2024 17:55:46 +0000

As Android developers, we often need to integrate custom applications and packages into the Android source code. This guide will walk you through the process of adding a custom vendor and its associated packages to your Android source tree.

Directory Structure Setup

First, create the following directory structure in your Android source code:

vendor/
└── oem/
    └── packages/
        └── applications/
            ├── Android.bp
            ├── packages.mk
            ├── permissions/
            │   └── com.sample.app.xml
            └── prebuilts/
                ├── SampleApp.apk
                ├── SampleAppWithPermission.apk
                └── SampleLauncher.apk

Configuration Files

1. Android.bp

The Android.bp file defines how your applications should be built and installed. Here's a breakdown of different types of app configurations:

// Basic Launcher Application
android_app_import {
    name: "SampleLauncher",
    privileged: true,
    apk: "prebuilts/SampleLauncher.apk",
    overrides: [
        "Launcher2",
        "Launcher3",
        "Launcher3QuickStep",
        "CarLauncher",
        "SnapdragonLauncher",
    ],
    presigned: true,
}

// Simple System Extension Application
android_app_import {
    name: "SampleApp",
    system_ext_specific: true,
    apk: "prebuilts/SampleApp.apk",
    optional_uses_libs: [
        "androidx.window.extensions",
        "androidx.window.sidecar",
    ],
    presigned: true,
}

// Privileged Application with Permissions
android_app_import {
    name: "SampleAppWithPermission",
    system_ext_specific: true,
    privileged: true,
    optional_uses_libs: [
        "androidx.window.extensions",
        "androidx.window.sidecar",
    ],
    apk: "prebuilts/SampleAppWithPermission.apk",
    required: ["privapp_whitelist_com.sample.app.xml"],
}

// Permission Configuration
prebuilt_etc {
    name: "privapp_whitelist_com.sample.app.xml",
    system_ext_specific: true,
    src: "permissions/com.sample.app.xml",
    sub_dir: "permissions",
    filename_from_src: true,
}

2. packages.mk

Create a packages.mk file to define which packages should be included in the build:

# Packages
PRODUCT_PACKAGES += \
    SampleLauncher \
    SampleApp \
    SampleAppWithPermission

3. Permission XML

For applications requiring privileged permissions, create a permission XML file:

<?xml version="1.0" encoding="utf-8"?>
<permissions>
    <privapp-permissions package="com.sample.app">
        <permission name="android.permission.CAPTURE_AUDIO_OUTPUT"/>
    </privapp-permissions>
</permissions>

Integration with Build System

To integrate your custom vendor packages into the Android build system, you need to include the packages.mk file in your device's product configuration. There are several ways to do this depending on your setup:

For standard handheld devices, add this line to build/make/target/product/handheld_product.mk:

include vendor/oem/packages/applications/packages.mk

For Qualcomm-based devices, you might need to add it to:
- device/qcom/qssi/qssi.mk
- device/qcom/qssi/qssi_au.mk
- Or your specific device's product makefile

Important Notes

APK Signing: Ensure your APKs are properly signed before adding them to the prebuilts directory. The presigned: true flag indicates that the APK is already signed.
Permissions: For privileged applications, make sure to:
- Set privileged: true in the Android.bp configuration
- Create appropriate permission XML files
- Reference the permission XML in the required field
System Extensions: Use system_ext_specific: true for apps that should be installed in the system_ext partition.
Override Existing Apps: Use the overrides array to replace existing system applications, as shown in the SampleLauncher configuration.

Conclusion

By following this guide, you can properly integrate custom vendor packages into your Android source code. Remember to test thoroughly and ensure all permissions are properly configured before building your system image.

Remember that the exact integration path might vary depending on your specific device tree and BSP (Board Support Package) configuration. Always consult your device's documentation for the most appropriate location to include custom packages.

Building Android Automotive OS: A Beginner-Friendly Guide

Harsh — Sun, 09 Jun 2024 22:01:27 +0000

Introduction

Android Automotive OS is a version of Android tailored for in-vehicle use. It provides a seamless experience for drivers and passengers by integrating various automotive functions with Android applications. This guide will walk you through the process of building Android Automotive OS from scratch, covering all the necessary tools, setup, and steps required.

Prerequisites

Before starting, ensure you have the following:

Computer with Linux or macOS: Building Android Automotive OS is most compatible with Linux-based systems or macOS.
Adequate System Resources: At least 16GB of RAM and 400GB of free disk space.
Internet Connection: To download necessary tools and dependencies.

Tools and Software Required

Java Development Kit (JDK): Java 8 or higher.
Repo Tool: To manage the Android source code.
Git: Version control system.
AOSP (Android Open Source Project) Source Code: Base source code for Android.
Android Studio: Latest stable version.

Step-by-Step Guide

1. Set Up Your Environment

Install Java Development Kit (JDK)

First, install the JDK. Open a terminal and run:

sudo apt update
sudo apt install openjdk-8-jdk

Install Required Packages

For Ubuntu 18.04 or later, install the necessary packages:

sudo apt-get update
sudo apt-get install git-core gnupg flex bison build-essential zip curl zlib1g-dev libc6-dev-i386 x11proto-core-dev libx11-dev lib32z1-dev libgl1-mesa-dev libxml2-utils xsltproc unzip fontconfig

Install Git

Ensure Git is installed by running:

sudo apt install git

Install Repo Tool

Download the Repo tool and make it executable:

mkdir ~/bin
curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
chmod a+x ~/bin/repo

Add Repo to your PATH:

export PATH=~/bin:$PATH

2. Download the Android Source Code

Create a directory for your Android build:

mkdir ~/android-automotive
cd ~/android-automotive

Initialize the Repo with the Android source code:

repo init -u https://android.googlesource.com/platform/manifest -b android-13.0.0_r83

Note: you can use any branch or tag which will be latest and depending on the project you are building like android-13.0.0_r83 or master

Synchronize the Repo to download the source code:

repo sync

3. Configure the Build

Set up the environment for the build:

source build/envsetup.sh

Choose a target:

lunch

Select an appropriate target, such as aosp_car_x86_64-userdebug.

4. Build the Android Automotive OS

Start the build process:

make -j$(nproc)

This process can take several hours depending on your system's performance.

5. Flash the Build to a Device or Emulator

Once the build is complete, you can flash it to an Android Automotive compatible device or run it on an emulator.

the below command will directly launch the emulator

emulator

Flash to Device

Connect your device and run:

adb reboot bootloader
fastboot flashall -w

Run on Emulator

To create an AVD (Android Virtual Device) for Automotive:

Open Android Studio.
Go to AVD Manager.
Create a new AVD with an automotive system image.
Start the emulator.

Conclusion

Building Android Automotive OS from scratch involves several steps, from setting up your environment to flashing the OS onto a device or emulator. By following this guide, you can get started with developing for the automotive platform and exploring its features.

For more detailed information, refer to the official Android Automotive OS documentation.

Resources

Feel free to leave comments or questions below, and I'll be happy to help you through the process!

Environment Setup: Ruby on Rails: Platform : Windows

Harsh — Thu, 17 Feb 2022 10:27:10 +0000

Environment setup of Ruby on Rails is a headache for newbie developers so let's how we can easily establish a link between the software and new developer. Just sit back and relax and follow :P ! Without wasting more time let's just get started

STEP 1:

Install Ruby installer from https://rubyinstaller.org/downloads/

Since I have x64 Windows machine hence I will be downloading that.

You can check yours using Windows
Settings > System > Scroll Down ( About) Your will see your System type as shown below :

What the Devkit version ?

RubyInstaller uses the MSYS2 toolchain as its development kit. It is bundled into the Ruby+Devkit installer version as a selectable component, so that no additional downloads/installs are required. It’s possible to share one Devkit among multiple versions of Ruby. MSYS2 is required in order to build native C/C++ extensions for Ruby and is necessary for Ruby on Rails

source: https://rubyinstaller.org/

STEP 2:

Open Installer install it as the normal application no need to interfere the default configuration just next next LOL!

STEP 3:

Setting up Environmental variable:

Search Environmental Variable in Start menu / Search Bar of Windows

This will open the window as shown below

Click on Environment Variable (at right down corner) as shown in image below:

Now to check it is successfully installed open command line (cmd)

(Search cmd in Start menu/Search bar)

Check this line it should contain the path of your ruby version mine is ( C:\Ruby30-x64\bin) if it is not there in your add it.

Type command ruby --version you will get the version name if installed successfully Kudos!

To setup binaries follow the steps here https://www.msys2.org/

download msys2 and as per instruction given in msys2 website do it. Now that you have done that all the binaries are installed we are very close to our missing Here after step 7 do type the following command in same terminal)

pacman -S mingw-w64-x86_64-yarn pacman -S mingw-w64-x86_64-nodejs

Nodejs and yarn are required for Webpacker and msys2 since both

Now we need to Install Rails :

Open cmd type below command

gem install rails

to check if successfully installed type rails --version

Build Ionic framework App Source and Artifact Android Apk Action

Harsh — Fri, 11 Sep 2020 14:03:23 +0000

My Workflow

his GitHub Action "Get Android Apk" is designed to automate the developers work to:

Configure the Java,Node.js,Ionic cli
Build from latest Ionic Source and make android source
Then Build the Android app from latest Source
Upload The build to the the Artifact for Testing on every changes done in master branch

Submission Category:

- Maintainer Must-Haves, DIY Deployments

Yaml File or Link to Code

name: Get Android APK

on: [push, pull_request]

jobs:
  build:
    name: Build APK
    runs-on: ubuntu-latest
    steps:
      - name: checkout source
        uses: actions/checkout@v2

      - name: setup java sdk
        uses: actions/setup-java@v1
        with:
          java-version: '9.0.4'

      - name: setup Node.js
        uses: actions/setup-node@v1
        with:
          node-version: 13.x

      - name: Install Cordova
        run: npm install -g cordova

      - name: Install Ionic cli
        run: npm install -g @ionic/cli

      - name: Install app dependencies
        run: npm install

      - name: build the app
        run: npm run build

      - name: remove existing folder if there 
        run: rm -rf {path of your android folder dir.} # eg. /home/runner/work/Bookie/Bookie/android

      - name: Add to android
        run: npx cap add android

      - name: sync with source
        run: npx cap sync

      - name: Generate the Android App Apk
        working-directory: {working android directory} # eg. /home/runner/work/Bookie/Bookie/android 
        run: bash ./gradlew assembleDebug --stacktrace

      - name: Upload dev APK
        uses: actions/upload-artifact@v1
        with:
          name: app-dev
          path: android/app/build/outputs/apk/debug/app-debug.apk

hpnightowl / Bookie

Pocket Alternative for Personal Use

Ionic Android APK Generator Action

This repository is dedicated to a GitHub Action for generating a new apk and pushing it to the repository, whenever changes are made in master branch.

Usage

Example Workflow file

An example workflow to set up your Ionic Android apk generator action quickly.

name: Get Android APK
on: [push, pull_request]

jobs:
  build:
    name: Build APK
    runs-on: ubuntu-latest
    steps:
      - name: checkout source
        uses: actions/checkout@v2

      - name: setup java sdk
        uses: actions/setup-java@v1
        with:
          java-version: '9.0.4'
          
      - name: setup Node.js
        uses: actions/setup-node@v1
        with:
          node-version: 13.x

      - name: Install Cordova
        run: npm install -g cordova

      - name: Install Ionic cli
        run: npm install -g @ionic/cli

      - name: Install app dependencies
        run: npm install

      - name: build the app
        run: npm run

…

View on GitHub

Additional Resources / Info

actions / checkout

Action for checking out a repo

Checkout V4

This action checks-out your repository under $GITHUB_WORKSPACE, so your workflow can access it.

Only a single commit is fetched by default, for the ref/SHA that triggered the workflow. Set fetch-depth: 0 to fetch all history for all branches and tags. Refer here to learn which commit $GITHUB_SHA points to for different events.

The auth token is persisted in the local git config. This enables your scripts to run authenticated git commands. The token is removed during post-job cleanup. Set persist-credentials: false to opt-out.

When Git 2.18 or higher is not in your PATH, falls back to the REST API to download the files.

What's new

Please refer to the release page for the latest release notes.

Usage

- uses: actions/checkout@v4
  with
    # Repository name with owner. For example, actions/checkout
    # Default: ${{ github.repository }}
    repository: ''

    # The branch, tag or SHA to

…

View on GitHub

actions / setup-java

Set up your GitHub Actions workflow with a specific version of Java

Setup Java

The setup-java action provides the following functionality for GitHub Actions runners:

Downloading and setting up a requested version of Java. See Usage for a list of supported distributions.
Extracting and caching custom version of Java from a local file.
Configuring runner for publishing using Apache Maven.
Configuring runner for publishing using Gradle.
Configuring runner for using GPG private key.
Registering problem matchers for error output.
Caching dependencies managed by Apache Maven.
Caching dependencies managed by Gradle.
Caching dependencies managed by sbt.
Maven Toolchains declaration for specified JDK versions.

This action allows you to work with Java and Scala projects.

V2 vs V1

V2 supports custom distributions and provides support for Azul Zulu OpenJDK, Eclipse Temurin and AdoptOpenJDK out of the box. V1 supports only Azul Zulu OpenJDK.
V2 requires you to specify distribution along with the version. V1 defaults to Azul Zulu OpenJDK, only version input is required…

View on GitHub

actions / setup-node

Set up your GitHub Actions workflow with a specific version of node.js

setup-node

This action provides the following functionality for GitHub Actions users:

Optionally downloading and caching distribution of the requested Node.js version, and adding it to the PATH
Optionally caching npm/yarn/pnpm dependencies
Registering problem matchers for error output
Configuring authentication for GPR or npm

Usage

See action.yml

- uses: actions/setup-node@v4
  with
    # Version Spec of the version to use in SemVer notation.
    # It also emits such aliases as lts, latest, nightly and canary builds
    # Examples: 12.x, 10.15.1, >=10.15.0, lts/Hydrogen, 16-nightly, latest, node
    node-version: ''

    # File containing the version Spec of the version to use.  Examples: package.json, .nvmrc, .node-version, .tool-versions.
    # If node-version and node-version-file are both provided the action will use version from node-version. 
    node-version-file: ''

    # Set this option if you want the action to check for the latest available version 
    # that satisfies the version spec.
    # It will only

…

View on GitHub

Made with ❤️ by hpnightowl