metadidomi-builder 1.4.201125 → 1.6.2812251812

package/build_tools/verify-apk-dependencies.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Vérificateur de dépendances dans l'APK final
+ * Extrait et analyse le classes.dex pour confirmer que toutes les classes sont présentes
+ */
+
+const projectDir = process.argv[2] || process.cwd();
+const buildDir = path.join(projectDir, 'build');
+const libsExtractedDir = path.join(buildDir, 'libs-extracted');
+const configPath = path.join(projectDir, 'app-config.json');
+
+console.log('🔍 Vérification des dépendances dans l\'APK\n');
+
+// Trouver l'APK généré
+const apkFiles = fs.readdirSync(projectDir).filter(f => f.endsWith('.apk'));
+if (apkFiles.length === 0) {
+    console.error('❌ Aucun fichier APK trouvé dans le projet');
+    process.exit(1);
+}
+
+const apkPath = path.join(projectDir, apkFiles[0]);
+console.log(`📦 APK cible: ${apkFiles[0]}`);
+console.log(`   Taille: ${(fs.statSync(apkPath).size / 1024 / 1024).toFixed(2)} MB\n`);
+
+// Déterminer le chemin de 7za
+function getSevenZipPath() {
+    const buildToolsDir = path.dirname(__filename);
+    const platform = process.platform;
+    const arch = process.arch;
+    
+    if (platform === 'win32') {
+        const archDir = arch === 'x64' ? 'x64' : (arch === 'arm64' ? 'arm64' : 'ia32');
+        return path.join(buildToolsDir, 'vendor', '7zip-bin', 'win', archDir, '7za.exe');
+    } else if (platform === 'linux') {
+        return path.join(buildToolsDir, 'vendor', '7zip-bin', 'linux', 'x64', '7za');
+    } else if (platform === 'darwin') {
+        return path.join(buildToolsDir, 'vendor', '7zip-bin', 'mac', 'x64', '7za');
+    }
+    
+    throw new Error(`Plateforme non supportée: ${platform}`);
+}
+
+const SEVENZIP = getSevenZipPath();
+const SDK = path.join(path.dirname(__filename), 'vendor', 'android', 'android-sdk');
+const AAPT2 = path.join(SDK, 'build-tools', '34.0.0', 'aapt2.exe');
+
+// Charger app-config pour avoir la liste des dépendances attendues
+let expectedDeps = [];
+if (fs.existsSync(configPath)) {
+    try {
+        const appConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (appConfig.dependencies && appConfig.dependencies.androidx) {
+            expectedDeps = appConfig.dependencies.androidx.map(d => ({
+                name: d.name,
+                filename: path.basename(d.aar || d.name)
+            }));
+        }
+    } catch (e) {
+        console.warn('⚠️  Impossible de lire app-config.json:', e.message);
+    }
+}
+
+// Extraire classes.dex depuis l'APK
+const tempDir = path.join(buildDir, `temp_apk_verify_${Date.now()}`);
+fs.mkdirSync(tempDir, { recursive: true });
+
+console.log('📥 Extraction de classes.dex depuis l\'APK...\n');
+
+try {
+    const extractCmd = `"${SEVENZIP}" x "${apkPath}" "classes.dex" -o"${tempDir}" -y`;
+    execSync(extractCmd, { stdio: 'pipe', shell: 'cmd.exe' });
+} catch (e) {
+    console.error('❌ Impossible d\'extraire classes.dex');
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.exit(1);
+}
+
+const classesDexPath = path.join(tempDir, 'classes.dex');
+if (!fs.existsSync(classesDexPath)) {
+    console.error('❌ classes.dex introuvable dans l\'APK');
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    process.exit(1);
+}
+
+const dexStats = fs.statSync(classesDexPath);
+console.log(`✓ classes.dex extrait (${(dexStats.size / 1024).toFixed(2)} KB)\n`);
+
+// Utiliser dexdump pour lister les classes dans le DEX
+console.log('📋 Analyse des classes dans classes.dex...\n');
+
+const dexdumpPath = path.join(SDK, 'build-tools', '34.0.0', 'dexdump.exe');
+let dexClasses = [];
+
+try {
+    const dumpCmd = `"${dexdumpPath}" "${classesDexPath}"`;
+    const output = execSync(dumpCmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+    
+    // Parser le output de dexdump pour extraire les noms de classes
+    // Format: Class descriptor  : 'Lcom/example/Class;'
+    const classRegex = /Class descriptor\s*:\s*'([^']+)'/g;
+    let match;
+    while ((match = classRegex.exec(output)) !== null) {
+        const className = match[1].slice(1, -1).replace(/\//g, '.');
+        dexClasses.push(className);
+    }
+    
+    console.log(`✓ Trouvé ${dexClasses.length} classes dans classes.dex\n`);
+} catch (e) {
+    console.warn('⚠️  Impossible d\'analyser classes.dex avec dexdump');
+    console.log('   Utilisation de l\'analyse alternative...\n');
+}
+
+// Analyser les JAR extraits pour compter les classes attendues
+console.log('📊 Analyse des dépendances téléchargées...\n');
+
+let expectedClasses = new Map();
+let totalExpectedClasses = 0;
+
+if (fs.existsSync(libsExtractedDir)) {
+    const extractedJars = fs.readdirSync(libsExtractedDir).filter(f => f.endsWith('.jar'));
+    
+    console.log(`Fichiers JAR extraits: ${extractedJars.length}\n`);
+    
+    for (const jarFile of extractedJars) {
+        const jarPath = path.join(libsExtractedDir, jarFile);
+        const jarTempDir = path.join(tempDir, `jar_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`);
+        fs.mkdirSync(jarTempDir, { recursive: true });
+        
+        try {
+            // Lister le contenu du JAR
+            const listCmd = `"${SEVENZIP}" l "${jarPath}"`;
+            const jarContent = execSync(listCmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            
+            // Compter les fichiers .class
+            const classFiles = (jarContent.match(/\.class$/gm) || []).length;
+            const packages = new Set();
+            
+            const pkgRegex = /([a-zA-Z0-9/_-]+)\/[^/]+\.class$/gm;
+            let m;
+            while ((m = pkgRegex.exec(jarContent)) !== null) {
+                packages.add(m[1].replace(/\//g, '.'));
+            }
+            
+            if (classFiles > 0) {
+                expectedClasses.set(jarFile, classFiles);
+                totalExpectedClasses += classFiles;
+                console.log(`  📦 ${jarFile}`);
+                console.log(`     Classes: ${classFiles}`);
+                if (packages.size > 0 && packages.size <= 10) {
+                    console.log(`     Packages: ${Array.from(packages).slice(0, 5).join(', ')}${packages.size > 5 ? '...' : ''}`);
+                }
+            }
+        } catch (e) {
+            console.warn(`  ⚠️  Erreur analyse ${jarFile}: ${e.message.substring(0, 50)}`);
+        }
+        
+        // Nettoyer
+        try {
+            fs.rmSync(jarTempDir, { recursive: true, force: true });
+        } catch (e) {}
+    }
+} else {
+    console.log('⚠️  Aucun répertoire libs-extracted trouvé');
+}
+
+// Rapport de synthèse
+console.log('\n' + '='.repeat(60));
+console.log('📊 RAPPORT DE SYNTHÈSE');
+console.log('='.repeat(60) + '\n');
+
+console.log('✅ Classes présentes dans classes.dex:');
+if (dexClasses.length > 0) {
+    console.log(`   ${dexClasses.length} classes totales`);
+    
+    // Grouper par package
+    const packageCounts = {};
+    for (const cls of dexClasses) {
+        const pkg = cls.substring(0, cls.lastIndexOf('.'));
+        packageCounts[pkg] = (packageCounts[pkg] || 0) + 1;
+    }
+    
+    const sortedPkgs = Object.entries(packageCounts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10);
+    
+    console.log('\n   Top 10 packages:');
+    for (const [pkg, count] of sortedPkgs) {
+        console.log(`     - ${pkg}: ${count} classes`);
+    }
+    
+    // Vérifier les packages AndroidX essentiels
+    console.log('\n   Vérification des packages essentiels:');
+    const essentialPackages = [
+        'androidx.appcompat',
+        'androidx.core',
+        'androidx.fragment',
+        'androidx.lifecycle',
+        'android.app',
+        'android.widget',
+        'com.google.android.material'
+    ];
+    
+    for (const pkg of essentialPackages) {
+        const found = Object.keys(packageCounts).filter(p => p.startsWith(pkg)).length > 0;
+        console.log(`     ${found ? '✓' : '✗'} ${pkg}`);
+    }
+} else {
+    console.log('   ⚠️  Impossible de lister les classes (dexdump non disponible)');
+}
+
+console.log('\n📦 Dépendances déclarées:');
+if (expectedDeps.length > 0) {
+    console.log(`   ${expectedDeps.length} dépendances `);
+    for (const dep of expectedDeps.slice(0, 10)) {
+        console.log(`     - ${dep.name}`);
+    }
+    if (expectedDeps.length > 10) {
+        console.log(`     ... et ${expectedDeps.length - 10} autres`);
+    }
+} else {
+    console.log('   ℹ️  Aucune dépendance déclarée détectée');
+}
+
+console.log('\n📥 JAR extraits à compiler:');
+if (expectedClasses.size > 0) {
+    console.log(`   ${expectedClasses.size} fichiers JAR`);
+    console.log(`   ${totalExpectedClasses} classes attendues au total`);
+} else {
+    console.log('   ℹ️  Aucun JAR trouvé');
+}
+
+// Vérification finale
+console.log('\n' + '='.repeat(60));
+if (dexClasses.length > 0 && dexClasses.length > 100) {
+    console.log('✅ RÉSULTAT: Les dépendances semblent correctement incluses');
+    console.log(`   (${dexClasses.length} classes détectées)`);
+} else if (dexClasses.length > 0) {
+    console.log('⚠️  RÉSULTAT: Nombre limité de classes détecté');
+    console.log(`   (${dexClasses.length} classes)`);
+    console.log('   Vérifiez que la compilation D8 a inclus tous les JAR');
+} else {
+    console.log('❌ RÉSULTAT: Impossible de vérifier les classes');
+    console.log('   Utilisez dexdump manuellement: dexdump classes.dex');
+}
+console.log('='.repeat(60) + '\n');
+
+// Nettoyer
+fs.rmSync(tempDir, { recursive: true, force: true });
+
+// Commandes de vérification manuelle
+console.log('💡 Pour une vérification manuelle:');
+console.log(`   1. Extraire classes.dex: 7z x ${apkFiles[0]} classes.dex`);
+console.log(`   2. Lister les classes: dexdump classes.dex | grep "Class descriptor"`);
+console.log(`   3. Ou utiliser: strings classes.dex | grep "^Landroidx/" | sort\n`);
+
+process.exit(0);