UniApp APK打包与Android深度集成能力解析

1. UniApp APK打包模式

1.1 云打包 vs 离线打包

• 云打包：DCloud服务器编译，无需本地环境
• 离线打包：本地Android Studio环境，完全自定义
• 混合打包：部分云打包，部分本地自定义

1.2 离线打包核心流程

# 1. 准备离线打包资源
# HBuilderX -> 发行 -> 原生App-云打包 -> 生成离线打包资源

# 2. 集成到Android Studio项目
# 将生成的资源文件复制到Android项目assets目录

# 3. 配置build.gradle
dependencies {
    implementation 'io.dcloud:uniapp:1.0.0'
    implementation 'io.dcloud:stream:1.0.0'  // 网络模块
    implementation 'io.dcloud:push:1.0.0'    // 推送模块
}

2. Android原生能力深度集成

2.1 自定义原生插件开发

// 自定义原生插件示例
public class CustomNativePlugin extends UniPlugin {
    
    @UniJSMethod(uiThread = false) // 非UI线程执行
    public void customFunction(JSONObject options, UniCallback callback) {
        try {
            String param = options.getString("param");
            
            // 执行原生操作
            String result = performCustomOperation(param);
            
            // 异步回调
            runOnUiThread(() -> {
                callback.success(result);
            });
        } catch (Exception e) {
            callback.error(e.getMessage());
        }
    }
    
    @UniJSMethod(uiThread = true) // UI线程执行
    public void uiOperation(JSONObject options, UniCallback callback) {
        // 需要在UI线程的操作
        Activity activity = getCurrentActivity();
        // 更新UI等操作
        callback.success("UI operation completed");
    }
}

2.2 系统级权限集成

// 权限管理插件
public class PermissionManagerPlugin extends UniPlugin {
    
    @UniJSMethod
    public void requestPermission(String permission, UniCallback callback) {
        if (ContextCompat.checkSelfPermission(
                getCurrentActivity(), 
                permission
        ) != PackageManager.PERMISSION_GRANTED) {
            
            ActivityCompat.requestPermissions(
                getCurrentActivity(),
                new String[]{permission},
                REQUEST_CODE
            );
        } else {
            callback.success("Permission granted");
        }
    }
    
    // 特殊权限处理
    @UniJSMethod
    public void requestSpecialPermission(String permission, UniCallback callback) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            if (permission.equals("SYSTEM_ALERT_WINDOW")) {
                if (!Settings.canDrawOverlays(getCurrentActivity())) {
                    Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                            Uri.parse("package:" + getCurrentActivity().getPackageName()));
                    getCurrentActivity().startActivityForResult(intent, REQUEST_CODE);
                }
            }
        }
    }
}

3. 高级原生功能集成

3.1 后台服务与推送

// 自定义后台服务
public class UniAppBackgroundService extends Service {
    private static final String CHANNEL_ID = "uniapp_background";
    
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        createNotificationChannel();
        startForeground(1, createNotification());
        
        // 执行后台任务
        scheduleBackgroundTask();
        
        return START_STICKY; // 服务被杀死后自动重启
    }
    
    private void scheduleBackgroundTask() {
        // 定时任务、数据同步等
        new Thread(() -> {
            while (true) {
                // 执行后台任务
                try {
                    Thread.sleep(30000); // 30秒间隔
                    syncDataWithServer();
                } catch (InterruptedException e) {
                    break;
                }
            }
        }).start();
    }
    
    private void syncDataWithServer() {
        // 与服务器同步数据
    }
}

3.2 硬件设备集成

// 蓝牙设备管理
public class BluetoothManagerPlugin extends UniPlugin {
    
    @UniJSMethod
    public void scanBLEDevices(JSONObject options, UniCallback callback) {
        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
        
        if (adapter == null || !adapter.isEnabled()) {
            callback.error("Bluetooth not available");
            return;
        }
        
        BluetoothLeScanner scanner = adapter.getBluetoothLeScanner();
        ScanCallback scanCallback = new ScanCallback() {
            @Override
            public void onScanResult(int callbackType, ScanResult result) {
                super.onScanResult(callbackType, result);
                // 扫描到设备后的处理
                JSONObject deviceInfo = new JSONObject();
                try {
                    deviceInfo.put("name", result.getDevice().getName());
                    deviceInfo.put("address", result.getDevice().getAddress());
                    deviceInfo.put("rssi", result.getRssi());
                    
                    // 通过uniapp回调
                    sendEvent("bleDeviceFound", deviceInfo);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        };
        
        scanner.startScan(scanCallback);
    }
    
    @UniJSMethod
    public void connectToDevice(String deviceAddress, UniCallback callback) {
        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
        BluetoothDevice device = adapter.getRemoteDevice(deviceAddress);
        
        BluetoothGatt gatt = device.connectGatt(getCurrentActivity(), false, gattCallback);
        callback.success("Connecting to device: " + deviceAddress);
    }
}

4. 性能优化与安全加固

4.1 WebView性能优化

// WebView优化配置
public class WebViewOptimizer {
    
    public static void optimizeWebView(WebView webView) {
        WebSettings settings = webView.getSettings();
        
        // 性能优化
        settings.setJavaScriptEnabled(true);
        settings.setDomStorageEnabled(true);
        settings.setDatabaseEnabled(true);
        settings.setCacheMode(WebSettings.LOAD_DEFAULT);
        
        // 硬件加速
        webView.setLayerType(View.LAYER_TYPE_HARDWARE, null);
        
        // 内存优化
        settings.setAppCacheEnabled(true);
        settings.setAppCachePath(webView.getContext().getCacheDir().getAbsolutePath());
        settings.setAllowFileAccess(true);
        settings.setAllowContentAccess(true);
    }
    
    // 自定义WebViewClient优化
    public static class OptimizedWebViewClient extends WebViewClient {
        @Override
        public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
            // 资源拦截和优化
            String url = request.getUrl().toString();
            if (isOptimizableResource(url)) {
                return optimizeResource(request);
            }
            return super.shouldInterceptRequest(view, request);
        }
    }
}

4.2 安全加固措施

// 安全配置
public class SecurityConfig {
    
    public static void setupSecurity(WebView webView) {
        WebSettings settings = webView.getSettings();
        
        // 安全设置
        settings.setAllowFileAccess(false);
        settings.setAllowContentAccess(false);
        settings.setAllowFileAccessFromFileURLs(false);
        settings.setAllowUniversalAccessFromFileURLs(false);
        
        // JavaScript安全
        webView.removeJavascriptInterface("searchBoxJavaBridge_");
        webView.removeJavascriptInterface("accessibility");
        webView.removeJavascriptInterface("accessibilityTraversal");
    }
    
    // URL白名单验证
    public static boolean isValidUrl(String url) {
        List<String> allowedDomains = Arrays.asList(
            "https://yourdomain.com",
            "https://cdn.yourdomain.com"
        );
        
        for (String domain : allowedDomains) {
            if (url.startsWith(domain)) {
                return true;
            }
        }
        return false;
    }
}

5. 鸿蒙系统适配

5.1 鸿蒙兼容性处理

// 鸿蒙系统检测与适配
public class HarmonyOSAdapter {
    
    public static boolean isHarmonyOS() {
        try {
            Class<?> buildExClass = Class.forName("com.huawei.system.BuildEx");
            Object osBrand = buildExClass.getDeclaredField("OS_BRAND").get(null);
            return "HarmonyOS".equalsIgnoreCase(osBrand.toString());
        } catch (Exception e) {
            return false;
        }
    }
    
    // 鸿蒙特定功能
    public static void setupHarmonyOSFeatures(Context context) {
        if (isHarmonyOS()) {
            // 启用鸿蒙分布式能力
            enableDistributedFeatures(context);
            
            // 适配鸿蒙UI规范
            applyHarmonyDesign(context);
        }
    }
    
    private static void enableDistributedFeatures(Context context) {
        // 分布式数据同步
        // 跨设备服务调用
        // 分布式文件系统
    }
}

6. 实用场景集成

6.1 文件系统深度集成

// 高级文件操作插件
public class AdvancedFilePlugin extends UniPlugin {
    
    @UniJSMethod
    public void copyFile(String sourcePath, String targetPath, UniCallback callback) {
        try {
            File sourceFile = new File(sourcePath);
            File targetFile = new File(targetPath);
            
            // 确保目标目录存在
            targetFile.getParentFile().mkdirs();
            
            // 复制文件
            Files.copy(sourceFile.toPath(), targetFile.toPath(), 
                      StandardCopyOption.REPLACE_EXISTING);
            
            callback.success("File copied successfully");
        } catch (IOException e) {
            callback.error("File copy failed: " + e.getMessage());
        }
    }
    
    @UniJSMethod
    public void compressFile(String sourcePath, String zipPath, UniCallback callback) {
        try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipPath))) {
            File sourceFile = new File(sourcePath);
            addToZip(zos, sourceFile, "");
            callback.success("File compressed successfully");
        } catch (IOException e) {
            callback.error("File compression failed: " + e.getMessage());
        }
    }
}

6.2 系统集成能力

// 系统级功能插件
public class SystemIntegrationPlugin extends UniPlugin {
    
    // 系统设置修改
    @UniJSMethod
    public void setSystemBrightness(int brightness, UniCallback callback) {
        try {
            Settings.System.putInt(
                getCurrentActivity().getContentResolver(),
                Settings.System.SCREEN_BRIGHTNESS,
                brightness
            );
            callback.success("Brightness set successfully");
        } catch (Settings.SettingNotFoundException e) {
            callback.error("Failed to set brightness: " + e.getMessage());
        }
    }
    
    // 系统音量控制
    @UniJSMethod
    public void setSystemVolume(int streamType, int volume, UniCallback callback) {
        AudioManager audioManager = (AudioManager) getCurrentActivity()
            .getSystemService(Context.AUDIO_SERVICE);
        
        audioManager.setStreamVolume(streamType, volume, 0);
        callback.success("Volume set successfully");
    }
    
    // 系统时间获取
    @UniJSMethod
    public void getSystemTime(UniCallback callback) {
        long currentTime = System.currentTimeMillis();
        callback.success(String.valueOf(currentTime));
    }
}

7. 开发调试与发布

7.1 调试工具集成

// 调试功能插件
public class DebugPlugin extends UniPlugin {
    
    @UniJSMethod
    public void logToConsole(String level, String message, UniCallback callback) {
        switch (level.toLowerCase()) {
            case "info":
                Log.i("UniApp", message);
                break;
            case "error":
                Log.e("UniApp", message);
                break;
            case "warn":
                Log.w("UniApp", message);
                break;
            default:
                Log.d("UniApp", message);
        }
        callback.success("Logged: " + message);
    }
    
    @UniJSMethod
    public void getMemoryInfo(UniCallback callback) {
        ActivityManager activityManager = (ActivityManager) 
            getCurrentActivity().getSystemService(Context.ACTIVITY_SERVICE);
        
        ActivityManager.MemoryInfo memInfo = new ActivityManager.MemoryInfo();
        activityManager.getMemoryInfo(memInfo);
        
        JSONObject result = new JSONObject();
        try {
            result.put("totalMem", memInfo.totalMem);
            result.put("availMem", memInfo.availMem);
            result.put("threshold", memInfo.threshold);
            result.put("lowMemory", memInfo.lowMemory);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        
        callback.success(result);
    }
}

8. 总结与建议

8.1 核心优势

• 开发效率：一套代码多端运行
• 原生能力：完整Android API访问
• 性能表现：接近原生应用性能
• 扩展性：灵活的插件机制

8.2 最佳实践

• 模块化设计：原生功能模块化管理
• 安全性优先：严格的安全配置
• 性能优化：合理的资源管理
• 兼容性测试：多版本Android测试