Develop Reference

Google Maps are not showing up in a signed apk

I know this is a common question and usually the solution is to generate a separate key for release. I've done it several times and my API key in developers console contains two different SHA1-fingerprints: one for debug from AndroidStudio and on for release from my own keystore. I have signed the app with the same keystore and enabled Google Maps Android API v2 in the console. But still the maps activity shows just the white screen with 'Google' in the left bottom corner.
Are there any suggestions how to solve the problem?

It sounds like you only have the API key entered in the debug google_maps_api.xml. Also, it sounds like you're using the same API key for debug and release, but you still need to enter it in the google_maps_api.xml under the release folder as well as the one in the debug folder.
It's a little confusing, because when the project is in Android view, you can only see the debug file (although it should have (debug) in parenthesis next to it in that view).
In order to modify the release version, switch to Project view by using the dropdown in the upper left of the Project Explorer. Then, expand app/src/, and you will see subfolders debug and release. Under there, you should see two separate google_maps_api.xml files under debug/res/values and release/res/values.
Make sure that the API key is populated in the google_maps_api.xml file under the release/res/values folder, since this is the one that will be used for the signed release apk.

If you chose Google Play App Signing then your App's SHA-1 will be different one when it will be released.
Because Google remove your uploaded certificate and then sign the App with a new one,
So you have to know the new SHA-1 key.
(You don't have to follow the log for release and track the new SHA-1 generated)
You can compare the 2 SHA-1 keys.
Origin answer

I solved it by looking at https://play.google.com/console in the left menu configuration then integrity of the app and copy the SHA1 of the upload key certificate that is below the SHA1 Certificate of the app signing key and add it in the same api key of https://console.cloud.google.com/. This way I didn't have to make changes to the apk.
If it doesn't work for you add both and try.

I did a lot of things to fix these but any solution not fix my problem
to fix these issue I did these things
Create signed apk with new keystore file make sure that the you will create that in release mode
After creating the signed apk you should note the keystore path where you save your keystore file.
You also need to use your google map API key with your release mode and debug mode both, you can use same API key with both but make sure that you should add two different sha keys for your single api key on google console.
You should go to use the path of bin folder of java from c drive because keystore tool is inside bin folder so
suppose your file is like C:\Program Files\Java\jdk1.8.0_11\bin
so you should follow this path to your android studio terminal
change the path to C:\Program Files\Java\jdk1.8.0_11\bin
and then type this command:
keytool -list -v -keystore "/Users/NT/Desktop/generalkey.jks"(adress of your keystore file)
Now by doing these you will get the sha key copy that key
Go to google console/credentials
Now go to your api you will see edit option go to edit and past your sha key into it and save it .
Run your code.

you are using a version of sha1. you need to again generate SHA1 using command prompt after making you apk signed.
Steps to regenerate SHA1 is go to cmd and give the command like below:
C:\Program Files\Java\jre1.8.0_91\bin>keytool -list -v -keystore
"C:\Your key store path\keystores\android.jks"
1)go to your java in program file open java version like jre1.8.0
2)open bin folder and run command like above follwed by your key store path that you have generated when you generated the signed apk
after running this command on cmd you need to provide password of signed app and your SHA1 will be gerarated.
3)copy the sha1 and paste into console.developer with your package name within your api key.

It's too late to answer but may be helpful for others if they phase the same issue.
If adding key in the release did not work then please check your SHA key in your jks file and add the same key in google play google api console
To get released SHA open your terminal and type
Asad-MacBook-Air:~ asad$ keytool -list -v -keystore /your/path/keystore.jks
and then check SHA, it should be the same as it is used in google api console.

this happend to me because we need two google maps api keys one for the debug and another one for the release, you can check in :
C:\Users\username\AndroidStudioProjects\yourapp\app\src\ debug \res\values
and you’ll find an xml with your api key like:
AIza...etc
but if you check here:
C:\Users\username\AndroidStudioProjects\yourapp\app\src\ release \res\values
you will find an xml but without api key inside like:
<string name="google_maps_key" templateMergeStrategy="preserve"
translatable="false">YOUR_KEY_HERE</string>

Android: Google Map v2 not showing map for release apk

My google map app works fine on device with debug google map API KEY but when I create signed apk for my app with release google map API KEY, it does not display map.
To generate release mode google API KEY , i am using SHA1 fingerprint with my keystore.
And i am also defining "signing and build types" in my project Settings as explained by developer.android.com(http://developer.android.com/tools/publishing/app-signing.html).
Tried every possible solution(removing apk and than reinstalling it again, restarting the device, cleaning the project ). nothing worked.
Anybody have a good solution to my problem please help.
FYI Using android studios platform.

Maybe you have two google_maps_api.xml files, one in the app/src/debug/res/values folder and the other in the app/src/release/res/values folder, but only the debug one contains your API key.

The API key needs to be hardcoded into the Android Manifest, and it doesn't work if it's in a separate resources XML file.

Debug certificate is different from your production certificate. You need to add both to your Google Maps key entry in your API console as seaparate row - each with the same packageId, but naturally different SHA1 hash.
EDIT
There's no limit of how many certificate fingerprints and package names are assigned to single Google Maps key, so unless you need this separated is's perfectly fine to have both development and production builds using the same key. In google console it would be like this (one sha1 is from debug cert, which is the same for all apps you build using this IDE, other is production cert):
83:10:58:52:EF:3B:59:70:2B:28:9E:AE:4F:5E:1D:F0:7E:19:FB:F1;com.foo.bar
AE:4F:5E:1D:F0:7E:19:FB:83:10:58:52:EF:3B:59:70:2B:28:9E:AA;com.foo.bar
or even (but I do not recommend using same key for different apps):
83:10:58:52:EF:3B:59:70:2B:28:9E:AE:4F:5E:1D:F0:7E:19:FB:F1;com.foobar.myapp
AE:4F:5E:1D:F0:7E:19:FB:83:10:58:52:EF:3B:59:70:2B:28:9E:AA;com.foo.bar
EF:3B:59:7E:19:FB:83:10:58:57:AE:4F:5E:1D:F0:2B:28:DE:9E:01;net.something.otherapp

I had this Problem and running these steps I think this way is perfect and complete
For Android Studio:
Build-Generate Signed APK
Copy Key Store Path.
Now open a command prompt and go to C:\Program Files\Java\jdk1.6.0_39\bin> (or any installed jdk version).
Type keytool -list -v -keystore and then paste your Key Store Path (e.g. C:\Program Files\Java\jdk1.6.0_39\bin>keytool -list -v -keystore "E:\My Projects \Android\android studio\signed apks\Hello World\HelloWorld.jks").
Now it will Ask Key Store Password, provide yours and press Enter to get your SHA1 and MD5 Certificate keys.
You Can See SHA1 For Your Debug Certificate and Use in Developer Google
Console

Sorry for replying late. Hope this helps for future.
I use this solution to solve same problem
When we are using Google maps while developing, a default debug.keystore is used which has no password. When we build apk file to upload on Play store new SHA-1 key is made so we have to make new debug.keystore for that. We have to create new API key for that SHA-1.
According to solution How to obtain Signing certificate fingerprint (SHA1) for OAuth 2.0 on Android? we can get SHA-1 for the exported apk file .
After that use that new API key in Android Manifest as the previous one and you are done.
EDIT 1-
Steps to do this
1) Create apk file using "Use the export Wizard" in "Android Manifest" file of your project.
2) After inserting key and before finishing, MD5 and SHA1 keys are shown as shown is this given pic- (http://i.stack.imgur.com/SldEv.png)
3) Create new API Key for Android project in https://console.developers.google.com for new SHA1 which is retrieved in point 2).
4)Use that API key in manifest file as shown below
5)Clean your project and build APK file again as per point 1).
6) You can see google maps now in that apk.

There are two things to remember and get this working.
Debug Build Variant
Generate a new android debug key using the keytool
Associate this key (SHA-1) with the android map api key on google console
The debug mode has a google_maps_api.xml where the android maps api key is stored (src/debug/.../google_maps_api.xml) as a string "google_maps_key"
Release Build Variant
Generate a new android release key using the keytool
Assoiciate this key (SHA-1) with a new android map api key on google console
The release mode has a google_maps_api.xml where the release android maps api key is stored (src/release/.../google_maps_api.xml) as a string "google_maps_key".
In the AndroidManifest.xml add the following line :
<meta-data
android:name="com.google.android.geo.API_KEY"
android:value="#string/google_maps_key" />
Follow the normal procedure for debug and release. It should work seamlessly.

create another Maps API key (to put in your manifest) corresponding with you release
keystore for release.
check Google's documentation

you cannot use same key that you used in debug in the release, they have different works.
to solve this problem you have to generate new Google map key API KEY form the key store that you are using in you release copy
see this video for more details
https://www.youtube.com/watch?v=xLJ0jDFdUZ0

for futures refs ---my case--- there are two google_maps_api.xml files where you need to put your google api key. You can very easily do the mistake to replace YOUR_API_KEY in only one of them (especially if you just deleted the google api/app and created new ones)

In the Google Api console, where we have created the API KEY we have an option to add multiple finger prints to the same key. What I did was adding two SHA1 finger print for my debug keystore and release keystore and the same API key worked for me.
Note the below is for Ubuntu specifically:
Get SHA1 for the debug using the below command
keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android
For getting SHA1 for release the command changes to
keytool -list -v -keystore /home/atul/Desktop/Learnings/Projects/TestApp/keystore.jks -alias test -storepass password -keypass password
where
/home/atul/Desktop/Learnings/Projects/TestApp/keystore.jks is the path where my keystore file for the signed apk is present
test is the key alias name used while genrating the signed key store
and password is the password used while signing the apk
Hope this helps. Happy coding :)

I had a similar issue and the problem was that I generated the apk from Android Studio without first selecting the right flavour. This means my manifest was still using the Google Maps API key that I created for the debug flavour.
Please make sure you select the release flavour in your Android Studio. See screenshot below:

How do I get the release api SHA1 fingerprint:
install your signed APK, from Playstore, or just copying it to the phone.
Plug USB cable if it is a real phone, and open Android Studio.
The first time you try to get maps, a Log entry will show something like:
E/Google Maps Android API: In the Google Developer Console (https://console.developers.google.com)
Ensure that the "Google Maps Android API v2" is enabled.
Ensure that the following Android Key exists:
API Key: AIzaS<YOUR KEY YOUR KEY YOUR KEY YOUR KEY>
Android Application (<cert_fingerprint>;<package_name>): 56:AF:B2:<THIS IS WHAT YOU ARE LOOKING FOR>;br.com.tinx.<your package>
then, just follow those instructions, creating a new entry in the Developer Console.
if you hit your app maps prior seeing the log, you may need to close app from memory and try again)
this procedure should work on an emulator too.

If you are created SHA1 code from custom keystore use the same in release mode. or generate apk by signing with that same keystore and test.
Before that you need clear app data (Setting->App-select app-Clear data->uninstall) and try. this worked for me.
Ensure that package name is same as that in google developer console.

I had a similar problem: after creating a couple of new variants builds with same type ("release") but some new flavors ("free" and "premium"), the Google Maps fragment did not show anymore the maps and the screen appeared totally blank. In the logcat I could only see next error message "Unexpected response code 400 for https://clients4.google.com/glm/mmap/api" that probably was indicating some problem with the Google Maps API access.
Of course I reviewed again all the Google Cloud API process in order to check if something was missing in my API key credentials, but I did not find anything wrong. In fact, for new APK's it is indicated to add the builds info (name+fingerprint) to the existing Project Credentials in order to inherit the same API key that is still valid.
The instructions that we can read are very clear: "Add your package name and SHA-1 signing-certificate fingerprint to restrict usage to your Android apps. Get the package name from your AndroidManifest.xml file. Then use the following command to get the fingerprint: keytool -list -v -keystore mystore.keystore".
The problem in my case was that my new variants "package names" were not the one existing in the Manifest package name ("com.example.app_name.release"). In fact, due to my new flavors I had the same Manifest name BUT two new "real" package names: "com.example.app_name.free.release" and "com.example.app_name.premium.release". Those names do not appear written in the Manifest file as such as they correspond to the Gradle configuration where flavors are defined (in my case with "applicationIdSuffix" attribute). This is quite confusing for me as Gradle "application id" should not overlap the Manifest "package name". But when we read carefully all the Android documentation, we can read "if manifest package name is different than Gradle applicationId, build will copy the application ID in final manifest file". Of course, both variants have the same fingerprint as both are still of the same build type ("release").
So the solution was to add in the same Project Credentials the two new variant entries to inherit the same API key:
original entry (don't need to delete it): Package name = "com.example.app_name.release" - SHA-1 certificate fingerprint = "xxxxx"
new entry 1: Package name = "com.example.app_name.free.release" - SHA-1 certificate fingerprint = "xxxxx" no change, same as used until now
new entry 2: Package name = "com.example.app_name.premium.release" - SHA-1 certificate fingerprint = "xxxxx" no change, same as used until now
Finally, it may be needed to clean your build in order to ensure that you are really watching the correct updated behavior in your maps fragment or activity.
About the rest of recommendations, in my case I did not have to apply them:
- no need to hardcode the API key in the Manifest
- no need to create a new API key for the new variants APK's
- no need to use the google_maps_api.xml files

Below method worked for me:
Put google maps api key in manifest as hardcoded text mentioned by #Florence Herrou
Android Studio creates inside:
app\src\debug\res\values\google_maps_api.xml (debug) //add key here
Add key inside ->
app\src\release\res\values\google_maps_api.xml (release) //add key here

Google key has two types of Security.
1.Non restricted key
2.Restricted key (Android restricted through SHA-1)
Note: Use Restricted key for Maps,Places, but not for Google Directions. use Non restricted api key for google Directions . bcz its web based api response so restricted key doesnt work.
-> When using Non Restricted key
look into two google_maps_api.xml files, one in the app/src/debug/res/values folder and the other in the app/src/release/res/values folder, but only the debug one contains your API key. make sure key is same in both files.
-> When usingRestricted (Android SHA-1) key
Step - 1 : look into two google_maps_api.xml files, one in the app/src/debug/res/values folder and the other in the app/src/release/res/values folder, but only the debug one contains your API key. make sure key is same in both files.
Step - 2 : Generate SHA-1 using AndroidStudio (gradle tab in Left Pane and select signing Report) and add as a item in google Developer console for the Api key which your using.
Step - 3: As soon as you generated Signed Apk google will overwrite your Androidstudio generated SHA-1 a with google own SHA-1 key. so u need to get tht also to be added for Api key in Api key in Developer console
Goto Release Management -> App Signing -> and copy the SHA-1 certificate fingerprint from App signing certificate
Paste this newly copied SHA-1 fingerprint to Developer Console and map in release mode will show.
Step 4: Add Release build SHA-1 also to Api key in Developer console like below.
Goto Release Management -> App Signing -> and copy the SHA-1 certificate fingerprint from Upload certificate
Paste this newly copied SHA-1 fingerprint to Developer Console and map in release mode will show.

Android SHA1 release keystore not working with Google Maps

I am using the Google Maps Android API and I'm running into some issues.
I am signing my apk with android studio (created one at .android/keystore.jks). Also I'm selecting "release" as type in it. I have used the command
keytool -list -v -keystore C:\Users\Toshiba\.android\keystore.jks
to get the SHA1 fingerprint out of the keystore.
The SHA1 is correct, but the Map is not shown on a signed APK. It is shown in a debug APK.
Using keytool with the release keystore (keystore.jks) will get me this:
SHA1: 33:46:07:82:5B:D4:45:D2:60:CE:5A:29:97:9F:6C:44:XX:XX:XX:XX
The debug one works fine (I have added 2 to the API console in Google)
33:46:07:82:5B:D4:45:D2:60:CE:5A:29:97:9F:6C:44:XX:XX:XX:XX;yac.breakingpoint
7C:28:61:5B:C3:4A:5C:50:44:AA:FD:58:69:E9:70:91:XX:XX:XX:XX;yac.breakingpoint
XX is blacked out.
The keytool says it is using SHA256withRSA as signature algorithm for both, the debug and the release keystore.
What am I doing wrong?
UPDATE
So I've tried a new API key, clean project and rebuild it, new keystore - still not working on release... debug is fine!
UPDATE 2
Still not found a working solution... Help me!
UPDATE 3 Allright, got it working using a signed APK with build type debug. Extracted the CERT.RSA and runned keytool -printcert -file ./CERT.SA. Got the same result as for the release build type. In release it is not working!
UPDATE 4
Here's another try I made:
Created a new GIT Repository, commited to it.
The /buildfolders are not beeing commited since they are in the .gitignore files.
Created a new API key in the API console and added only the release SHA1 key to it.
Added that API key to the app and made a full clean with rebuild.
Generated a new signed APK file
It did not work.
UPDATE 5
A friend of mine tried to reproduce this issue. He has the exact same issue when working with android studio. Probably a android studio bug?

You have two google_maps_api.xml files
One in this folder:
app/src/debug/res/values
Other in this folder:
app/src/release/res/values
But only the debug one contains your API key probably.

1) Usually, you have to Clean and Rebuild the Project so it can work.
2) Make sure your build variant is on Release (Android Studio is friendly on this)
3) Also if you are debugging on your devices fully uninstall first then continue.
4) As the documentation says, make sure you have set up your manifest correctly.
Hope it helps.

Create new project in Android Studio with Google map Activity. After project automatically creates the SHA1 in the manifest. Use this SHA1 to get MAP api key. Test your app be sure it works. And after build you app on what project.

the SHA1 currently you are using for debugging purpose .
So when you are creating a signed apk u have one kestore file. try to generate new SHA1 key with this new keaystore file.
then using this keystore file create API key for signed apk from google console.
replace debug API key already stored in manifest file with the new one.
It will work
thanks

You also need to add SHA-1 generated by Google App signing certificate.
Once you publish your app you can find it in Google Play Console -> Development Tools -> Release management -> App signing -> App signing certificate.
More details on this in this here: Google Places for Android API key does not work on app from Play Store

Map is not working after installing from play store in android

I'm stuck in this issue, when i run my project in eclipse it shows map correct, but when i upload it to Google play store and when i install it in my device , it shows the blank map,
I don't know what is a problem my map key is correct, package name is correct, i also generate new map key and try, but it also doesn't work. I don't know where is the issue.

Please follow the check-list :
1) Sign the app with new .keystore.
2) SHA1 of new .keystore should be used.
3) Map key should be made using this SHA1.
4) If new Google account is used, then make sure Android Maps V2 services is turned on for that account.

As this type of issue was already raised and there was the solutions
Google Map Android API v2 can't display map in play store application

This problem is because of map api key.
You need to sign your app and find keystore for signed app.
Right click on project
Android Tools->Export Signed application pachage->next -> create new keystore
then use this new keysore to find new SHA1
Now find new API key for your app.
And replace the old map API key with this in manifest.
Next time whenever you want new signed app just use this keystore no need to create new again.

Make sure you update the SHA-1 in the play store from the location
Select your App --> App Integrity --> App signing key certificate --> SHA-1 certificate fingerprint.
Paste it into Release Key along with the app package name.

You need to do the following things to get your Maps Visible for both Debug Mode and release mode
-1 Add debug key to package combination at Google API console
-2 Add release key to page combination at Google API Console
Note : you need to add at lease 2 combination to get your maps visible when you are testing and when you generate *.apk file.
What you are missing right now is not adding the release key to application package combination to API console add this and after that do the following:
replace your debug map key with release key and generate your *.apk and install aplication to your device you will get your maps
there are several Tutorial available on net i would to suggest you the following one
Google Maps
To Generate the Release key do the following steps
Open CMD (in Windows) terminal (in Linux?MAC os) find the path to your jdk dir and then to bin like following:
C:\path-to-jdk\jdk1.7.0_07\bin>keytool -v -list -alias tt -keystore path-to-keystore -storepass password -keypass passowrd
for me the path is following for Jdk/bin and that for key store
C:\Program Files\Java\jdk1.7.0_07\bin>keytool -v -list -alias tt -keystore D:\ke
yStore -storepass password -keypass password
you need to give the following things of your own
-1 path to jdk
-2 path to keystore
-3 keystore passoword
-4 keypass password
Also look http://android-er.blogspot.in/2012/12/displaying-sha1-certificate-fingerprint.html for more information

How to get production key for google map?

When i am exporting apk the google map does not shown in my application. I need to put production key for exporting apk. I don't have any idea about how to get production key. If any one knows answer just share with me. Pls, give me a step by step solution. I already tried with below link.
http://developer.android.com/tools/publishing/app-signing.html

Generally there are two keys debug key and release key. while signing app, you want to use release key. For that you want to compare that with signed apk
Step 1:
Say for example your apk name is A and you are signing and creating a keystore for A.apk ie A.keystore will be created in some drive location.Let's consider it in E drive.
step 2:
Now locate to jdk in C drive(Considering for windows and assigning C drive)
C:\Program Files\Java\jdk1.7.0\bin>keytool -list -v -keystore E:\A.keystore -alias A
So it will create SHA-1 fingure print
copy and paste that in google map console, it wll generate a key.use it in maps.

You didn't specify which version of Google Maps you want to use. Note that Google stopped giving away keys for the first maps version, so you'll need to use Maps V2 (or API V3).