FloatMenu Android Library

To publish the library to GitHub Packages, follow these steps:

1. Configure build.gradle: Add the maven-publish plugin and define the publishing block. Ensure you set the groupId (typically your GitHub username), artifactId, and version.
2. Set Credentials: Add your GitHub username and a Personal Access Token (with repo and write:packages permissions) to your local.properties file using the keys gpr.user and gpr.key.
3. Execute Publication: Run the Gradle publish command.

Credentials in local.properties:

gpr.user=YOUR_GITHUB_USERNAME
gpr.key=YOUR_GITHUB_TOKEN

// 1. Add plugins to build.gradle
plugins {
    id 'com.android.library'
    id 'maven-publish'
}

version = "2.4.0"
group = "com.github.fanofdemo"

// 2. Configure publishing
afterEvaluate {
    publishing {
        publications {
            release(MavenPublication) {
                from components.release
                groupId = 'com.github.fanofdemo'
                artifactId = 'FloatMenu'
                version = '2.4.0'
                // ... pom configuration
            }
        }
        repositories {
            maven {
                name = "GitHubPackages"
                url = "https://maven.pkg.github.com/fanOfdemo/FloatMenuSample"
                credentials {
                    username = System.getenv("GITHUB_USER") || project.findProperty("gpr.user") ?: System.getenv("USERNAME")
                    password = System.getenv("GITHUB_TOKEN") || project.findProperty("gpr.key") ?: System.getenv("TOKEN")
                }
            }
        }
    }
}

# 3. Run the publish command
./gradlew publish

To prevent memory leaks and ensure proper cleanup, manage the FloatMenu instance within the Activity lifecycle:

1. onResume(): Initialize and show the menu if it hasn't been created.
2. onPause(): Call .hide() to hide the menu when the activity is not in focus.
3. onDestroy(): Call .destroyFloat() to completely remove the menu and clean up resources.

@Override
protected void onResume() {
    super.onResume();
    if (mFloatMenu == null) {
        mFloatMenu = FloatMenu.create(this)
                .logo(R.drawable.logo)
                .items(items)
                .show();
    }
}

@Override
protected void onPause() {
    super.onPause();
    if (mFloatMenu != null) {
        mFloatMenu.hide();
    }
}

@Override
protected void onDestroy() {
    if (mFloatMenu != null) {
        mFloatMenu.destroyFloat();
        mFloatMenu = null;
    }
    super.onDestroy();
}

To use FloatMenu in your Android project via GitHub Packages, you must configure your repository settings and add the dependency.

1. Configure Repositories

In your project's settings.gradle file, add the GitHub Packages Maven URL within the dependencyResolutionManagement block. It is highly recommended to use environment variables for credentials to avoid exposing your GitHub Token.

2. Add Dependency

Add the FloatMenu implementation to your module's build.gradle file using the specific group and version.

3. Public Access

If the package is not public, users must provide credentials. To make the package accessible without authentication, change the package visibility to 'Public' in the GitHub Package settings under the 'Danger Zone'.

// settings.gradle
dependencyResolutionManagement {
    repositories {
        maven {
            url = "https://maven.pkg.github.com/fanOfDemo/FloatMenuSample"
            credentials {
                // Recommended: Use environment variables
                username = System.getenv("GITHUB_USER")
                password = System.getenv("GITHUB_TOKEN")
            }
        }
    }
}

// build.gradle
dependencies {
    implementation 'com.github.fanofdemo:FloatMenu:2.4.0'
}

You can automate the release process to GitHub Packages using GitHub Actions. This workflow triggers whenever a new tag matching v*.*.* is pushed to the repository.

Create a workflow file at .github/workflows/release.yml to handle the checkout, JDK setup, and the Gradle publish task using the built-in GITHUB_TOKEN secret.

name: Release to GitHub Packages

on:
  push:
    tags:
      - 'v*.*.*'

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Grant execute permission for gradlew
        run: chmod +x gradlew

      - name: Publish to GitHub Packages
        run: ./gradlew :FloatMenu:publish
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

To show the menu outside the application context (on the desktop), you must use a Service and request the SYSTEM_ALERT_WINDOW permission.

1. Add Permission to AndroidManifest.xml: <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />

2. Implement Service: In onCreate, initialize the menu using FloatMenu.create(getApplicationContext()). In onDestroy, call mFloatMenu.destroyFloat() to clean up.

3. Register Service in AndroidManifest.xml:

   <service android:name=".FloatMenuService" android:enabled="true" android:exported="false" />

4. Start/Stop Service from your Activity: startService(new Intent(this, FloatMenuService.class));

public class FloatMenuService extends Service {
    private FloatMenu mFloatMenu;

    @Override
    public void onCreate() {
        super.onCreate();
        initFloatMenu();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (mFloatMenu != null) {
            mFloatMenu.show();
        }
        return START_STICKY;
    }

    @Override
    public void onDestroy() {
        if (mFloatMenu != null) {
            mFloatMenu.destroyFloat();
        }
        super.onDestroy();
    }

    private void initFloatMenu() {
        List<FloatItem> items = new ArrayList<>();
        items.add(new FloatItem("首页", R.drawable.icon_home));

        mFloatMenu = FloatMenu.create(getApplicationContext())
            .logo(R.drawable.logo)
            .items(items)
            .location(FloatMenu.LEFT)
            .show();
    }
}