深度链接 #

<!-- ios/App/App/Info.plist -->
<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>myapp</string>
        </array>
        <key>CFBundleURLName</key>
        <string>com.company.myapp</string>
    </dict>
</array>

<!-- android/app/src/main/AndroidManifest.xml -->
<activity android:name=".MainActivity" ...>
    
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data android:scheme="myapp" />
    </intent-filter>
    
</activity>

<!-- 网页链接 -->
<a href="myapp://profile/123">打开用户资料</a>
<a href="myapp://product?id=456">查看商品</a>

import { App } from '@capacitor/app';

// 监听URL打开
App.addListener('appUrlOpen', (data) => {
    console.log('URL opened:', data.url);
    
    // 解析URL
    const url = new URL(data.url);
    const path = url.pathname;
    const params = url.searchParams;
    
    // 根据路径导航
    if (path.startsWith('/profile/')) {
        const userId = path.split('/')[2];
        router.push(`/profile/${userId}`);
    } else if (path.startsWith('/product')) {
        const productId = params.get('id');
        router.push(`/product/${productId}`);
    }
});

Target → Signing & Capabilities → + Capability → Associated Domains

添加: applinks:example.com

// https://example.com/.well-known/apple-app-site-association
{
    "applinks": {
        "details": [
            {
                "appID": "TEAMID.com.company.myapp",
                "paths": ["*"]
            }
        ]
    }
}

# Nginx配置
location /.well-known/apple-app-site-association {
    default_type application/json;
    alias /var/www/.well-known/apple-app-site-association;
}

# 确保HTTPS
server {
    listen 443 ssl;
    server_name example.com;
    
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;
}

// ios/App/App/AppDelegate.swift
import UIKit
import Capacitor

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(_ application: UIApplication, 
                     continue userActivity: NSUserActivity, 
                     restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
        
        if userActivity.activityType == NSUserActivityTypeBrowsingWeb,
           let url = userActivity.webpageURL {
            
            // 通知Capacitor
            ApplicationDelegateProxy.shared.application(
                application,
                continue: userActivity,
                restorationHandler: restorationHandler
            )
            
            return true
        }
        
        return false
    }
}

// JavaScript处理
import { App } from '@capacitor/app';

App.addListener('appUrlOpen', (data) => {
    // data.url: https://example.com/profile/123
    handleDeepLink(data.url);
});

function handleDeepLink(url: string) {
    const parsedUrl = new URL(url);
    
    // 路由处理
    switch (parsedUrl.pathname) {
        case '/profile':
            const userId = parsedUrl.searchParams.get('id');
            router.push(`/profile/${userId}`);
            break;
        case '/product':
            const productId = parsedUrl.searchParams.get('id');
            router.push(`/product/${productId}`);
            break;
        default:
            router.push(parsedUrl.pathname);
    }
}

// https://example.com/.well-known/assetlinks.json
[{
    "relation": ["delegate_permission/common.handle_all_urls"],
    "target": {
        "namespace": "android_app",
        "package_name": "com.company.myapp",
        "sha256_cert_fingerprints": [
            "14:6D:E9:83:C5:CE:..."
        ]
    }
}]

keytool -list -v -keystore my-release-key.jks

<activity android:name=".MainActivity" ...>
    
    <intent-filter android:autoVerify="true">
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        
        <data android:scheme="https" />
        <data android:host="example.com" />
    </intent-filter>
    
</activity>

// MainActivity.java
@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    
    if (Intent.ACTION_VIEW.equals(intent.getAction())) {
        Uri uri = intent.getData();
        if (uri != null) {
            // 处理深度链接
            handleDeepLink(uri.toString());
        }
    }
}

// JavaScript处理
import { App } from '@capacitor/app';

App.addListener('appUrlOpen', (data) => {
    handleDeepLink(data.url);
});

// src/services/deeplink.service.ts
import { App } from '@capacitor/app';
import { Capacitor } from '@capacitor/core';

type DeepLinkHandler = (params: Record<string, string>) => void;

interface DeepLinkRoute {
    path: string | RegExp;
    handler: DeepLinkHandler;
}

class DeepLinkService {
    private routes: DeepLinkRoute[] = [];
    private initialized = false;
    
    async init(): Promise<void> {
        if (this.initialized) return;
        
        // 监听应用打开URL
        await App.addListener('appUrlOpen', (data) => {
            this.handleUrl(data.url);
        });
        
        // 检查冷启动时的URL
        const launchUrl = await this.getLaunchUrl();
        if (launchUrl) {
            this.handleUrl(launchUrl);
        }
        
        this.initialized = true;
    }
    
    private async getLaunchUrl(): Promise<string | null> {
        try {
            const { url } = await App.getLaunchUrl();
            return url;
        } catch {
            return null;
        }
    }
    
    register(path: string | RegExp, handler: DeepLinkHandler): void {
        this.routes.push({ path, handler });
    }
    
    private handleUrl(url: string): void {
        console.log('Deep link URL:', url);
        
        try {
            const parsedUrl = new URL(url);
            const pathname = parsedUrl.pathname;
            const params = Object.fromEntries(parsedUrl.searchParams);
            
            // 匹配路由
            for (const route of this.routes) {
                if (this.matchPath(route.path, pathname)) {
                    route.handler(params);
                    return;
                }
            }
            
            console.warn('No handler for deep link:', pathname);
        } catch (error) {
            console.error('Error parsing deep link:', error);
        }
    }
    
    private matchPath(pattern: string | RegExp, pathname: string): boolean {
        if (pattern instanceof RegExp) {
            return pattern.test(pathname);
        }
        
        return pathname === pattern || pathname.startsWith(pattern + '/');
    }
}

export const deepLinkService = new DeepLinkService();

// 初始化
await deepLinkService.init();

// 注册路由
deepLinkService.register('/profile', (params) => {
    const userId = params.id;
    router.push(`/profile/${userId}`);
});

deepLinkService.register('/product', (params) => {
    const productId = params.id;
    router.push(`/product/${productId}`);
});

deepLinkService.register(/^\/article\/\d+$/, (params) => {
    // 匹配 /article/123 格式
    router.push(window.location.pathname);
});

# 测试URL Scheme
xcrun simctl openurl booted "myapp://profile/123"

# 测试Universal Links
xcrun simctl openurl booted "https://example.com/profile/123"

# 测试URL Scheme
adb shell am start -a android.intent.action.VIEW \
    -d "myapp://profile/123"

# 测试App Links
adb shell am start -a android.intent.action.VIEW \
    -d "https://example.com/profile/123"

# iOS验证
curl -v https://example.com/.well-known/apple-app-site-association

# Android验证
curl -v https://example.com/.well-known/assetlinks.json

class DeferredDeepLinkService {
    private storageKey = 'deferred_deep_link';
    
    async saveDeferredLink(url: string): Promise<void> {
        await Preferences.set({
            key: this.storageKey,
            value: JSON.stringify({
                url,
                timestamp: Date.now()
            })
        });
    }
    
    async getDeferredLink(): Promise<string | null> {
        const { value } = await Preferences.get({ key: this.storageKey });
        
        if (!value) return null;
        
        const data = JSON.parse(value);
        
        // 检查是否过期（24小时）
        if (Date.now() - data.timestamp > 24 * 60 * 60 * 1000) {
            await this.clearDeferredLink();
            return null;
        }
        
        return data.url;
    }
    
    async clearDeferredLink(): Promise<void> {
        await Preferences.remove({ key: this.storageKey });
    }
}