Android: choisissez automatiquement la clé api de débogage / libération Maps?

OBSOLETED: cette ancienne question fait référence à l’API obsolète de Google Maps v1. Lors de l’utilisation de l’API v2, vous pouvez utiliser plusieurs empreintes de certificate dans une entrée de la console Google API . La clé API n’est plus stockée dans le manifeste ni dans le code.


Est-il possible de détecter automatiquement, quel certificate a été utilisé pour signer APK? Je voudrais avoir à la fois les certificates de débogage et de libération de Maps dans l’application et transmettre un un valide au constructeur MapView.

Avec une telle configuration, je ne ferai pas d’erreur lors de la publication de l’application. J’utilise un certificate de débogage sur l’émulateur et mon périphérique, puis je me connecte à la première version avant d’envoyer l’application à Market.

Je pensais à détecter mon périphérique particulier ou si le débogueur est connecté mais ce n’est pas parfait. Peut-être qu’un marquage de fichier nécessite un certificate de débogage? Y a-t-il une meilleure façon?

Il existe un nouveau moyen de déterminer s’il s’agit d’une version de débogage ou d’une version dans les outils du SDK, révision 17 . Un extrait de la vue d’ensemble des nouvelles fonctionnalités:

Les builds génèrent maintenant une classe appelée BuildConfig contenant une constante DEBUG définie automatiquement en fonction de votre type de build. Vous pouvez vérifier la constante ( BuildConfig.DEBUG ) dans votre code pour exécuter les fonctions de débogage uniquement.

Alors maintenant, vous pouvez simplement écrire quelque chose comme ceci:

if (BuildConfig.DEBUG) { //Your debug code goes here } else { //Your release code goes here } 

MISE À JOUR: J’ai rencontré un bogue dans ADT: parfois BuildConfig.DEBUG est true après l’exportation du package d’application. La description est ici: http://code.google.com/p/android/issues/detail?id=27940

J’ai eu le même problème avec la clé API. Voici une solution complète, basée sur le lien ci-dessus et l’ exemple de Bijarni (qui en quelque sorte n’a pas fonctionné pour moi), j’utilise maintenant cette méthode:

 // Define the debug signature hash (Android default debug cert). Code from sigs[i].hashCode() protected final static int DEBUG_SIGNATURE_HASH = ; // Checks if this apk was built using the debug certificatee // Used eg for Google Maps API key determination (from: http://whereblogger.klaki.net/2009/10/choosing-android-maps-api-key-at-run.html) public static Boolean isDebugBuild(Context context) { if (_isDebugBuild == null) { try { _isDebugBuild = false; Signature [] sigs = context.getPackageManager().getPackageInfo(context.getPackageName(), PackageManager.GET_SIGNATURES).signatures; for (int i = 0; i < sigs.length; i++) { if (sigs[i].hashCode() == DEBUG_SIGNATURE_HASH) { Log.d(TAG, "This is a debug build!"); _isDebugBuild = true; break; } } } catch (NameNotFoundException e) { e.printStackTrace(); } } return _isDebugBuild; } 

Vous devez trouver la signature hashValue () de votre signature de débogage, simplement sortir sigs [i] .hashCode ().

Ensuite, je ne voulais pas append dynamicment MapView, mais plutôt utiliser le fichier xml. Vous ne pouvez pas définir l'atsortingbut de clé api dans le code et utiliser une disposition xml. J'utilise donc cette méthode simple (bien que la copie de la présentation XML ne soit pas très belle):

Dans mon MapActivity:

  public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Select the proper xml layout file which includes the matching Google API Key if (isDebugBuild(this)) { setContentView(R.layout.map_activity_debug); } else { setContentView(R.layout.map_activity_release); } 

Un moyen beaucoup plus facile de déterminer s’il s’agit d’une version de débogage consiste à vérifier l’indicateur de débogage sur les informations de l’application par rapport au hachage de signature.

 public boolean isDebugBuild() throws Exception { PackageManager pm = _context.getPackageManager(); PackageInfo pi = pm.getPackageInfo(_context.getPackageName(), 0); return ((pi.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0); } 

Une fois la version de débogage trouvée, vous pouvez utiliser différentes ressources pour afficher la carte ou créer la vue cartographique dans l’application et l’append à une mise en page.

  if(isDebugBuild()) { _mapView = new MapView(this, getSsortingng(R.ssortingng.debugmapskey)); } else { _mapView = new MapView(this, getSsortingng(R.ssortingng.releasemapskey)); } 

J’ai contourné la mauvaise intégration des clés d’API dans le processus de génération et le contrôle des sources en en faisant une propriété stockée dans local.properties . J’ai dû append ce qui suit à build.xml :

   You need to add mapsApiKey=... to local.properties         

Maintenant, bien sûr, je devais créer mapview.xml.tpl dans la racine de mes projets (il ne peut pas aller à res/layout car cela va casser le processus de compilation):

   

Lors de la pré-compilation, le modèle est copié au bon endroit et @ apiKey @ est remplacé par la clé réelle. Malheureusement, je n’ai pas trouvé de moyen de faire la distinction entre les versions de débogage et de publication dans cette phase, donc pour comstackr la version, je viens d’append la version apiKey aux parameters ant:

 ant -DmapsApiKey=.... release 

Cette approche s’intègre bien avec SCM (je n’ai pas besoin d’enregistrer les clés) et de manière acceptable avec le processus de construction.

Si vous êtes toujours intéressé, je viens juste de bloguer sur une autre façon de le faire. Avec une simple modification du script de génération Android, vous pouvez basculer la clé de l’API de carte ainsi que toutes les autres modifications de version requirejses. Ce que j’aime à ce sujet, c’est que rien dans le débogage n’entre dans la version, et vous pouvez conserver les mises en page XML exactement comme avant.

http://blog.cuttleworks.com/2011/02/android-dev-prod-builds/

Je pense que créer une entrée dans la console de l’API Google qui inclut à la fois votre clé de version et votre clé de débogage (tous deux mappés sur le même package) fonctionne très bien et constitue un moyen beaucoup plus simple de ne pas vous soucier du débogage ou de la compilation. version finale. La solution est décrite ici

Toutes les réponses ici semblent obsolètes, si vous utilisez Android Studio, alors Gradle est la voie à suivre

Utilisez des clés différentes dans votre build.gradle

 android { .. .. ... buildTypes { debug { resValue "ssortingng", "google_maps_api_key", "[YOUR DEV KEY]" } release { resValue "ssortingng", "google_maps_api_key", "[YOUR PROD KEY]" } } } 

Et dans votre AndroidManifest.xml

  

la source

Et si vous voulez enregistrer certains mots de passe pour le débogage et la publication différemment, vous devriez suivre cette

J’ai fini avec le fichier spécial sur la carte SD – si présent, utilisez la clé de débogage; manquant – utilisez une version. Et il fonctionne.

EDIT: voir la nouvelle réponse acceptée, ça marche mieux

Je ne sais pas si cela aide quelqu’un mais j’ai fusionné certaines des autres suggestions ici pour produire le MapViewActivity suivant.

Dans cet exemple, R.layout.map_dbg est utilisé uniquement s’il s’agit d’une version de débogage et que le fichier existe (ajoutez ce fichier à votre fichier .gitignore).

Les avantages de cette approche sont les suivants:

  1. vous n’avez pas besoin d’écrire une cible ant (bon si vous utilisez éclipse)
  2. la clé de version correcte est toujours dans map.xml (espérons qu’une clé de débogage ne sera pas enregistrée par erreur)
  3. la clé de version est toujours utilisée pour une version release
  4. plusieurs clés de débogage peuvent être utilisées

Les inconvénients de cette approche sont les suivants:

  1. vous devez vous rappeler de mettre à jour map_dbg.xml à chaque mise à jour de map.xml

     public class MapViewActivity extends MapActivity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // // copy the map.xml to map_dbg.xml and update the api key. // int id = getLayoutId("map_dbg"); if(id ==0) id = R.layout.map; setContentView(id); } int getLayoutId(Ssortingng name) { return isDebugBuild() ? getResources().getIdentifier(name, "layout", getPackageName()) : 0; } public boolean isDebugBuild() { boolean dbg = false; try { PackageManager pm = getPackageManager(); PackageInfo pi = pm.getPackageInfo(getPackageName(), 0); dbg = ((pi.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0); } catch (Exception e) { } return dbg; } } 

J’ai mis en place une cible de fourmi simple qui remplace l’apikey avec une clé de débogage ou une clé de version. C’est très simple et garde le code exempt de logique indésirable.

       template-file: ${template-file}   

Dans Map V2 Il est facile d’envoyer des clés séparées en utilisant l’outil Android Studio Gradle. J’ai mis en place un moyen facile pour cela. s’il vous plaît vérifier le lien ici .