如何在Cordova应用中程序化检测当前分发渠道（Track/Channel）？

Great question—this is totally achievable without having to build separate app flavors for each track. Since you're promoting builds across Alpha/Beta/Production (Android) or TestFlight/Production (iOS) via app store promotion workflows, we can detect the track at runtime using platform-native APIs, then bridge that info to your Cordova JavaScript code.

Let's break this down by platform:

Android Implementation #

On Android, Google Play provides track details via the Google Play Core Library, which lets you fetch the current track a build was installed from (even if the same APK was promoted to multiple tracks).

1. Add the Google Play Core dependency
   Open platforms/android/app/build.gradle and add this to your dependencies block:

   dependencies {
       implementation 'com.google.android.play:core:1.10.3' // Use latest stable version
   }
   

2. Build a custom Cordova plugin (or extend an existing one)
   Create a native plugin class to handle the track detection:

   import com.google.android.play.core.install.InstallSourceInfo;
   import com.google.android.play.core.appupdate.AppUpdateManager;
   import com.google.android.play.core.appupdate.AppUpdateManagerFactory;
   import org.apache.cordova.CordovaPlugin;
   import org.apache.cordova.CallbackContext;
   import org.json.JSONArray;
   import org.json.JSONException;
   
   public class TrackDetector extends CordovaPlugin {
       @Override
       public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
           if (action.equals("getCurrentTrack")) {
               AppUpdateManager appUpdateManager = AppUpdateManagerFactory.create(cordova.getActivity());
               appUpdateManager.getInstallSourceInfo()
                   .addOnSuccessListener(installSourceInfo -> {
                       // Track names are typically "alpha", "beta", or "production"
                       String trackName = installSourceInfo.trackName();
                       callbackContext.success(trackName);
                   })
                   .addOnFailureListener(e -> {
                       // Fallback: Check if installed via Google Play
                       String installerPackage = cordova.getActivity()
                           .getPackageManager()
                           .getInstallerPackageName(cordova.getActivity().getPackageName());
                       if ("com.android.vending".equals(installerPackage)) {
                           callbackContext.success("production");
                       } else {
                           callbackContext.error("Failed to retrieve track info");
                       }
                   });
               return true;
           }
           return false;
       }
   }
   

3. Call the native code from JavaScript
   Wrap the Cordova exec call in a promise for cleaner usage:

   function getAndroidTrack() {
       return new Promise((resolve, reject) => {
           cordova.exec(resolve, reject, "TrackDetector", "getCurrentTrack", []);
       });
   }
   
   // Usage example
   getAndroidTrack().then(track => {
       console.log("Android track:", track);
       switch(track) {
           case "alpha":
               // Configure alpha-specific behavior (e.g., test API key)
               break;
           case "beta":
               // Configure beta-specific behavior
               break;
           default:
               // Production configuration
       }
   }).catch(err => console.error("Track fetch failed:", err));
   

iOS Implementation #

For iOS, the most reliable way to distinguish TestFlight from Production is checking the App Store receipt environment. The same IPA will have different receipt contexts depending on whether it's installed via TestFlight or the official App Store.

1. Build a custom Cordova plugin for iOS
   Create an Objective-C plugin class to detect the receipt environment:

   #import <StoreKit/StoreKit.h>
   #import <Cordova/CDVPlugin.h>
   
   @interface TrackDetector : CDVPlugin
   - (void)getCurrentTrack:(CDVInvokedUrlCommand*)command;
   @end
   
   @implementation TrackDetector
   
   - (void)getCurrentTrack:(CDVInvokedUrlCommand*)command {
       CDVPluginResult* result;
       NSURL *receiptURL = [[NSBundle mainBundle] appStoreReceiptURL];
       BOOL isSandbox = [[receiptURL lastPathComponent] isEqualToString:@"sandboxReceipt"];
   
       if (isSandbox) {
           // TestFlight (or Ad Hoc) environment
           result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:@"testflight"];
       } else {
           // Production App Store environment
           result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:@"production"];
       }
   
       [self.commandDelegate sendPluginResult:result callbackId:command.callbackId];
   }
   
   @end
   

2. Call from JavaScript
   Again, use a promise wrapper for consistency:

   function getIOSTrack() {
       return new Promise((resolve, reject) => {
           cordova.exec(resolve, reject, "TrackDetector", "getCurrentTrack", []);
       });
   }
   
   // Usage example
   getIOSTrack().then(track => {
       console.log("iOS track:", track);
       if (track === "testflight") {
           // TestFlight-specific setup
       } else {
           // Production setup
       }
   }).catch(err => console.error("Track fetch failed:", err));
   

Cross-Platform Integration #

Combine both platform-specific functions into a single, unified helper that auto-detects the current platform:

function getCurrentDistributionTrack() {
    return new Promise((resolve, reject) => {
        if (!window.cordova) {
            reject("Cordova is not initialized");
            return;
        }

        switch(cordova.platformId) {
            case "android":
                getAndroidTrack().then(resolve).catch(reject);
                break;
            case "ios":
                getIOSTrack().then(resolve).catch(reject);
                break;
            default:
                reject("Unsupported platform");
        }
    });
}

// Initialize on app ready
document.addEventListener("deviceready", () => {
    getCurrentDistributionTrack().then(track => {
        console.log("Current distribution track:", track);
        // Apply global configurations based on track
        window.APP_CONFIG = {
            apiKey: track.includes("test") || track === "alpha" || track === "beta" 
                ? "TEST_API_KEY" 
                : "PROD_API_KEY"
        };
    }).catch(err => {
        console.warn("Failed to detect track, using default config:", err);
        window.APP_CONFIG = { apiKey: "DEFAULT_API_KEY" };
    });
}, false);

Key Notes #

• For Android, ensure you're using Google Play Core Library v1.10.0+ (the trackName() method was added in this version).
• On iOS, receipt detection won't work in simulators—test on a physical device with a TestFlight or App Store installed build.
• If you support other app stores (e.g., Huawei, Xiaomi), extend the Android logic to check for their installer package names.

内容的提问来源于stack exchange，提问作者Frédéric Camblor