Implement APK Optimization Process

### Description
The current APK building process does not include optimization steps to reduce APK size and improve performance. This results in potentially larger and slower APKs than necessary.

### Current Behavior
- APKs are built without optimization steps
- No code minification or resource optimization
- Potential for larger APK sizes and slower performance

### Expected Behavior
- Optimize APK size and performance during the build process
- Implement zipalign to optimize data alignment
- Remove unused resources when possible

### Proposed Solution
Enhance the APK building process with optimization steps:

1. Add zipalign step to the build process:
```javascript
function optimizeApk(inputPath, outputPath, cb) {
const zipalignCommand = `zipalign -v -p 4 "${inputPath}" "${outputPath}"`;

console.log('Running optimization: zipalign');
cp.exec(zipalignCommand, (error, stdout, stderr) => {
if (error) {
console.error('zipalign failed:', stderr);
// Fall back to unoptimized APK
fs.copyFileSync(inputPath, outputPath);
return cb(null, false); // Indicate optimization failed but build continues
}
return cb(null, true); // Optimization succeeded
});
}
```

2. Update the build function to include optimization:
```javascript
function buildAPK(cb) {
// First clean up and build
// ...existing build code...

// After successful build, optimize
const unoptimizedApk = CONST.apkBuildPath;
const optimizedApk = CONST.apkBuildPath + '.opt';

optimizeApk(unoptimizedApk, optimizedApk, (err, optimized) => {
if (err) return cb(err);

if (optimized) {
fs.renameSync(optimizedApk, unoptimizedApk);
console.log('APK optimized successfully');
} else {
console.log('APK optimization skipped, using standard build');
}

// Continue with signing
signAPK(cb);
});
}
```

### Additional Context
APK optimization can significantly improve app performance and user experience, especially on lower-end devices.

---

## Issue 9: Fix MainActivity.smali Backtick Character Issues

### Description
The decompiled `MainActivity.smali` file contains backtick characters that cause syntax errors when attempting to rebuild the APK.

### Current Behavior
Building the APK fails with:
```
app/factory/decompiled/smali/com/etechd/l3mon/MainActivity.smali[743,0] Error for input '`': Invalid text
app/factory/decompiled/smali/com/etechd/l3mon/MainActivity.smali[743,1] Error for input '`': Invalid text
app/factory/decompiled/smali/com/etechd/l3mon/MainActivity.smali[743,2] Error for input '`': Invalid text
Could not smali file: com/etechd/l3mon/MainActivity.smali
```

### Expected Behavior
The `MainActivity.smali` file should be automatically cleaned of invalid characters during the build process.

### Proposed Fix
Implement a pre-build cleaning function in `apkBuilder.js`:

```javascript
/**
* Fix invalid characters in smali files
*/
function fixSmaliSyntax(cb) {
const mainActivityPath = path.join(CONST.decompileDir, 'smali/com/etechd/l3mon/MainActivity.smali');

fs.access(mainActivityPath, fs.constants.F_OK, (err) => {
if (err) {
// File doesn't exist, nothing to fix
return cb(null);
}

fs.readFile(mainActivityPath, 'utf8', (err, data) => {
if (err) return cb(`Failed to read MainActivity.smali: ${err.message}`);

// Replace invalid backtick characters
const cleanedData = data.replace(/```/g, '').replace(/`/g, '\'');

fs.writeFile(mainActivityPath, cleanedData, 'utf8', (err) => {
if (err) return cb(`Failed to write fixed MainActivity.smali: ${err.message}`);
return cb(null);
});
});
});
}
```

Then call this function before running the build command.

### Additional Context
This issue is likely caused by the decompilation process incorrectly handling certain characters in the original APK.

---

## Issue 10: Create Missing Dependencies Directory

### Description
The APK building process fails because it tries to use a directory for framework dependencies that doesn't exist.

### Current Behavior
When building the APK, the following warning is shown:
```
S: WARNING: Could not write to (/Users/username/Library/apktool/framework), using /var/folders/... instead...
S: Please be aware this is a volatile directory and frameworks could go missing
```

### Expected Behavior
The system should create and use a stable directory for APK framework dependencies.

### Proposed Fix
Create a dedicated directory for framework files and ensure it exists before building:

```javascript
// In const.js
exports.frameworkDir = path.join(__dirname, '../app/factory/framework');

// In initialization code
function ensureDirectoriesExist() {
const directories = [
CONST.downloadsFullPath,
CONST.frameworkDir,
path.dirname(CONST.apkBuildPath)
];

directories.forEach(dir => {
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
console.log(`Created directory: ${dir}`);
}
});
}

// Call this function during app startup
ensureDirectoriesExist();
```

### Additional Context
Having a stable framework directory will prevent APKTool from using temporary directories that might be deleted between builds.