Android Platform Types

/**
 * Complete Android project configuration
 */
interface AndroidProjectConfig {
  /** Source directory containing Java/Kotlin code (e.g., "android/app/src/main/java") */
  sourceDir: string;
  /** Application name as defined in Android manifest */
  appName: string;
  /** Java package name (e.g., "com.mycompany.myapp") */
  packageName: string;
  /** Android application ID for builds */
  applicationId: string;
  /** Main activity class name */
  mainActivity: string;
  /** Gradle dependency configuration (e.g., "implementation", "api") */
  dependencyConfiguration?: string;
  /** Additional command parameters for watch mode */
  watchModeCommandParams?: string[];
  /** Asset directories for this platform */
  assets: string[];
}

import { AndroidProjectConfig } from "@react-native-community/cli-types";

// Standard Android project configuration
const androidConfig: AndroidProjectConfig = {
  sourceDir: "android/app/src/main/java",
  appName: "MyReactNativeApp",
  packageName: "com.mycompany.myapp",
  applicationId: "com.mycompany.myapp",
  mainActivity: "MainActivity",
  dependencyConfiguration: "implementation",
  watchModeCommandParams: ["--verbose"],
  assets: ["./android/app/src/main/assets"]
};

// Validate Android configuration
function validateAndroidConfig(config: AndroidProjectConfig): boolean {
  const requiredFields = ['sourceDir', 'appName', 'packageName', 'applicationId', 'mainActivity'];
  return requiredFields.every(field => !!config[field as keyof AndroidProjectConfig]);
}

// Get app identifiers
function getAndroidIdentifiers(config: AndroidProjectConfig) {
  return {
    appName: config.appName,
    packageName: config.packageName,
    applicationId: config.applicationId,
    mainActivity: config.mainActivity
  };
}

/**
 * Parameters for Android project configuration with optional fields
 */
type AndroidProjectParams = {
  /** Source directory (optional, will be detected if not provided) */
  sourceDir?: string;
  /** Application name (optional, will be detected from manifest) */
  appName?: string;
  /** Path to AndroidManifest.xml (optional, will be detected) */
  manifestPath?: string;
  /** Java package name (optional, will be detected from manifest) */
  packageName?: string;
  /** Gradle dependency configuration */
  dependencyConfiguration?: string;
  /** Additional command parameters for watch mode */
  watchModeCommandParams?: string[];
  /** Asset directories */
  assets?: string[];
};

import { AndroidProjectParams } from "@react-native-community/cli-types";

// Minimal Android parameters (auto-detection)
const minimalParams: AndroidProjectParams = {
  dependencyConfiguration: "implementation"
};

// Full Android parameters
const fullParams: AndroidProjectParams = {
  sourceDir: "android/app/src/main/java",
  appName: "MyApp",
  manifestPath: "android/app/src/main/AndroidManifest.xml",
  packageName: "com.mycompany.myapp",
  dependencyConfiguration: "api",
  watchModeCommandParams: ["--info", "--stacktrace"],
  assets: ["./assets", "./android/app/src/main/assets"]
};

// Create parameters from existing config
function paramsFromConfig(config: AndroidProjectConfig): AndroidProjectParams {
  return {
    sourceDir: config.sourceDir,
    appName: config.appName,
    packageName: config.packageName,
    dependencyConfiguration: config.dependencyConfiguration,
    watchModeCommandParams: config.watchModeCommandParams,
    assets: config.assets
  };
}

/**
 * Complete Android dependency configuration supporting various module types
 */
type AndroidDependencyConfig = {
  /** Source directory of the dependency */
  sourceDir: string;
  /** Import path for the package in Java/Kotlin (null if no import needed) */
  packageImportPath: string | null;
  /** Package instance creation code (null if no instance needed) */
  packageInstance: string | null;
  /** Gradle dependency configuration (e.g., "implementation", "api") */
  dependencyConfiguration?: string;
  /** Build types this dependency supports */
  buildTypes: string[];
  /** Library name for native modules (null for non-native) */
  libraryName?: string | null;
  /** Component descriptors for Fabric components (null if not applicable) */
  componentDescriptors?: string[] | null;
  /** Path to CMakeLists.txt for C++ modules (null if no CMake) */
  cmakeListsPath?: string | null;
  /** CMake module name for C++ modules (null if no CMake) */
  cxxModuleCMakeListsModuleName?: string | null;
  /** CMake lists path for C++ modules (null if no CMake) */
  cxxModuleCMakeListsPath?: string | null;
  /** Header name for C++ modules (null if no C++) */
  cxxModuleHeaderName?: string | null;
  /** Whether this is a pure C++ dependency (no Java/Kotlin code) */
  isPureCxxDependency?: boolean;
};

import { AndroidDependencyConfig } from "@react-native-community/cli-types";

// Java/Kotlin library dependency
const javaLibraryDep: AndroidDependencyConfig = {
  sourceDir: "android",
  packageImportPath: "com.mylibrary.MyLibraryPackage",
  packageInstance: "new MyLibraryPackage()",
  dependencyConfiguration: "implementation",
  buildTypes: ["debug", "release"],
  libraryName: "mylibrary",
  componentDescriptors: null,
  cmakeListsPath: null,
  cxxModuleCMakeListsModuleName: null,
  cxxModuleCMakeListsPath: null,
  cxxModuleHeaderName: null,
  isPureCxxDependency: false
};

// C++ module dependency
const cppModuleDep: AndroidDependencyConfig = {
  sourceDir: "android",
  packageImportPath: null,
  packageInstance: null,
  dependencyConfiguration: "implementation",
  buildTypes: ["debug", "release"],
  libraryName: "mycppmodule",
  componentDescriptors: null,
  cmakeListsPath: "android/CMakeLists.txt",
  cxxModuleCMakeListsModuleName: "mycppmodule",
  cxxModuleCMakeListsPath: "android/src/main/cpp/CMakeLists.txt",
  cxxModuleHeaderName: "mycppmodule.h",
  isPureCxxDependency: true
};

// Fabric component dependency
const fabricComponentDep: AndroidDependencyConfig = {
  sourceDir: "android",
  packageImportPath: "com.mycomponent.MyComponentPackage",
  packageInstance: "new MyComponentPackage()",
  dependencyConfiguration: "implementation",
  buildTypes: ["debug", "release"],
  libraryName: "mycomponent",
  componentDescriptors: ["MyComponentComponentDescriptor"],
  cmakeListsPath: null,
  cxxModuleCMakeListsModuleName: null,
  cxxModuleCMakeListsPath: null,
  cxxModuleHeaderName: null,
  isPureCxxDependency: false
};

// Check dependency type
function analyzeDependencyType(dep: AndroidDependencyConfig): string {
  if (dep.isPureCxxDependency) return "Pure C++ Module";
  if (dep.componentDescriptors?.length) return "Fabric Component";
  if (dep.cmakeListsPath) return "Hybrid Java/C++ Module";
  if (dep.packageImportPath) return "Java/Kotlin Library";
  return "Unknown";
}

/**
 * Parameters for Android dependency configuration with optional auto-detection fields
 */
type AndroidDependencyParams = {
  /** Source directory (optional, will be detected) */
  sourceDir?: string;
  /** Path to AndroidManifest.xml (optional, will be detected) */
  manifestPath?: string;
  /** Java package name (optional, will be detected) */
  packageName?: string;
  /** Gradle dependency configuration */
  dependencyConfiguration?: string;
  /** Import path for the package (optional, will be detected) */
  packageImportPath?: string;
  /** Package instance creation code (optional, will be detected) */
  packageInstance?: string;
  /** Build types this dependency supports */
  buildTypes?: string[];
  /** Library name for native modules */
  libraryName?: string | null;
  /** Component descriptors for Fabric components */
  componentDescriptors?: string[] | null;
  /** Path to CMakeLists.txt for C++ modules */
  cmakeListsPath?: string | null;
  /** CMake module name for C++ modules */
  cxxModuleCMakeListsModuleName?: string | null;
  /** CMake lists path for C++ modules */
  cxxModuleCMakeListsPath?: string | null;
  /** Header name for C++ modules */
  cxxModuleHeaderName?: string | null;
};

import { AndroidDependencyParams } from "@react-native-community/cli-types";

// Minimal parameters (auto-detection)
const minimalDependencyParams: AndroidDependencyParams = {
  dependencyConfiguration: "implementation"
};

// Parameters for Java library
const javaLibraryParams: AndroidDependencyParams = {
  sourceDir: "android",
  packageImportPath: "com.mylibrary.MyLibraryPackage",
  packageInstance: "new MyLibraryPackage()",
  dependencyConfiguration: "implementation",
  buildTypes: ["debug", "release"],
  libraryName: "mylibrary"
};

// Parameters for C++ module
const cppModuleParams: AndroidDependencyParams = {
  sourceDir: "android",
  dependencyConfiguration: "implementation",
  libraryName: "mycppmodule",
  cmakeListsPath: "android/CMakeLists.txt",
  cxxModuleCMakeListsModuleName: "mycppmodule",
  cxxModuleHeaderName: "mycppmodule.h"
};

// Convert parameters to full config (simulated auto-detection)
function simulateConfigGeneration(
  params: AndroidDependencyParams,
  detectedValues: Partial<AndroidDependencyConfig>
): AndroidDependencyConfig {
  return {
    sourceDir: params.sourceDir || detectedValues.sourceDir || "android",
    packageImportPath: params.packageImportPath || detectedValues.packageImportPath || null,
    packageInstance: params.packageInstance || detectedValues.packageInstance || null,
    dependencyConfiguration: params.dependencyConfiguration || "implementation",
    buildTypes: params.buildTypes || ["debug", "release"],
    libraryName: params.libraryName || detectedValues.libraryName || null,
    componentDescriptors: params.componentDescriptors || null,
    cmakeListsPath: params.cmakeListsPath || null,
    cxxModuleCMakeListsModuleName: params.cxxModuleCMakeListsModuleName || null,
    cxxModuleCMakeListsPath: params.cxxModuleCMakeListsPath || null,
    cxxModuleHeaderName: params.cxxModuleHeaderName || null,
    isPureCxxDependency: !!(params.cmakeListsPath && !params.packageImportPath)
  };
}

import { Config, AndroidProjectParams, AndroidDependencyParams } from "@react-native-community/cli-types";

// The Android platform configuration is accessed through Config.platforms.android
// Note: AndroidPlatformConfig type is not exported, but the platform is accessible

// Generate Android project config from parameters
function generateAndroidProjectConfig(
  config: Config,
  projectRoot: string,
  params?: AndroidProjectParams
): AndroidProjectConfig | void {
  return config.platforms.android.projectConfig(projectRoot, params);
}

// Generate Android dependency config
function generateAndroidDependencyConfig(
  config: Config,
  dependency: string,
  params: AndroidDependencyParams
): AndroidDependencyConfig | void {
  return config.platforms.android.dependencyConfig(dependency, params);
}

// Check if project has Android support
function hasAndroidSupport(config: Config): boolean {
  return !!config.project.android;
}

// Access Android platform through config
function getAndroidSettings(config: Config) {
  const androidPlatform = config.platforms.android;
  return {
    npmPackageName: androidPlatform.npmPackageName,
    hasProjectConfig: typeof androidPlatform.projectConfig === 'function',
    hasDependencyConfig: typeof androidPlatform.dependencyConfig === 'function'
  };
}