For upload my application on google playstore. I have generated signedapk so my question is after made few changes in code of the app Shall i generate signed apk again ?
Yes.
You done some changes in your code.
if you want your changes generate apk.
There is no other way to do.
Yes it's mandatory to resign the APK whenever you want to regenerate the app, otherwise the application will not be updated if you are using Google Play
https://developer.android.com/studio/publish/app-signing.html
Definitely. before uploading application to the Play Store, you should always generate signed APK.
It would be better if you do it with ProGuard, it will provide security to your application.
There are several other things to taken care of while generating signed apk.
Proguard
Enable Minify
Shrink Resources
String Localization
Turn off Logging and Debugging
Delete unused files
Change Version Name and Version Code
Test your application throughout after doing all these things, there are chances that some things might not work after enabling Proguard and shrink resources. So its better to solve them and build apk again.
For more information, you can visit this link.
https://developer.android.com/studio/publish/app-signing.html
Related
Recently Google has asked me to remove one permission (SEND_SMS) from my android app and republish it. The problem is that I got this prebuilt app from some company and now they are asking for extra amount for only changing this permission. During initial purchase also I had told them not to include but they kept it. Now I want to edit android menifest by removing the permission for SEND_SMS, rebuild and sign the app and publish.Please note that I don't have the source code of the project, but my work I believe is only limited to android menifest. Is it even possible? if yes, How?
Thanks,
Abdul Wahid
Even if you manage to manipulate the manifest, you still can not sign the .apk. You would need the keystore file to sign it for publishing.
If you still have the keystore, then you can use apktool to decompile the APK, modify the manifest to increase the versionCode and remove that permission, then recompile it (still using apktool). Finally, re-sign the APK with apksigner using the keystore you have and publish the modified APK to Play Console.
I recently made my first app in Android Studio and made it into an APK. Google play said I had the wrong signature for the APK but I don't know how to change the APK with different signatures nor revert the program back in order to manually change it inside Android Studio. Any help on this?
Here is step by step what I did to get to this point. I finished writing my program and went to "build" then "generate signed apks" where I went through the process of making the keys, key store etc. At this point everything is fine. I just need to somehow go back into the apk and either change the signatures of it or unpack the apk in studio and redo the process of generating signed apks.
You need to sign the apk with the same public-key certificate which you use in the previous uploaded apk. When you build the release apk via Build -> Generate Signed Apk.., you will be presented with the following dialog:
Then you must use the same certificate file (something like android.jks) for the Key store path.
The documentation says:
Every app must use the same certificate throughout its lifespan in
order for users to be able to install new versions as updates to the
app. For more about the benefits of using the same certificate for all
your apps throughout their lifespans, see Signing Considerations
below.
So, if you lose the certificate file, there is no way you can upload the apk with the same package name again. It will lose forever, gone. You also can't delete the published apk to reuse the same package name again.
I have been given an APK file from my mobile developers and I need to upload this to the store. It says, you need to compile it in release mode. Is there a way in which i can do that to the apk, get it to become in release mode and sign it with a key, without having to get the developers to actually re-compile?
If no, can I extract an apk file, put it in ant and recompile to release mode?
I don't believe you can do this without recompiling and resigning. You need to change the AndroidManifest and re-sign it using the same key as was used to upload it the first time if it was previously uploaded.
I have an android app which is available on google play.
While creating an apk for release, there was a keystore that was created for signing.
My question is, if after the release, I have some enhancements underway (like facebook or google+ integration), which requires that the dev registers his app using the keystore, which keystore do I use?
Should it be the debug keystore (~/.android/debug.keystore) or the one that was created while packaging my app?
EDIT
Thanks for the answers so far.
To confirm, from the below answers I understand that, when testing this enhancement (before deploying the app to play store) & to register my app at facebook, I will be using the keystore that was used for signing the first apk file for this app and NOT the 'debug.keystore'. Correct?
But, while testing, wouldn't my app be sending 'debug.keystore', if I am building on eclipse platform? Or does the 'debug.keystore' become invalid once I have a new keystore generated for creating the previous apk file?
It's rather too confusing, and want to be clear with this...
You have to use, keystore which is used for generating apk file for playstore. Dont use another keystore, becoz it will give new one but wont updated the old one.
debug keystore (~/.android/debug.keystore) is not going to work for you.
As you mention that your application is already available in Google Play, that means while singing your application it ask Create new Keystore or use Existing one
Then choose Use existing keystore
Give your existing keystore path, and password.
This will give you a build that you can release in Google Play..
Before that make sure that increase the android:versionCode and android:versionName
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="YOUR_PACKAGE"
android:versionCode="1"
android:versionName="1.0" >
Hope this help you.
Plz ask if having any sort of problem.
You have to use your signing keystore which you used while uploading your app to developer console. The one that was created while packaging your app
only used for your signing keystore because already you release the application in play store so you can use new key that time is not release for updated version it's a one of the new application so you can use previous kestore for your updated appp.
This question on SO tells that the difference is in some files. My question is what difference does it make if I distribute my unsigned apk file, the one found in /bin folder. While publishing on market we have to create a keystore and export signed app but what if I dont go through the full process and just send or distribute the apk that is signed with debug key (say for peer review).
Edit: I'm not trying to put unsigned app on market, just on few devices to check.
Is there any 'problem' in distributing/installing the app signed with developer key ?
The developer key's maximum lifetime is one year. After that, the APK will no longer be usable. And, since that one-year lifetime is set when the key is created (when you first run the Android SDK build tools, or when you regenerate the key), it is conceivable that your APK will no longer work as of, say, tomorrow.
Also, someone who has installed your app with the developer key will need to uninstall it to install your production-signed APK later on, so make sure they understand this.
Also, each developer, by default, has their own developer key, and so I suggest that you be consistent with which member of your development team is creating APKs for use outside your firm.
Otherwise, I cannot think of any particular problems with using such an APK for testing purposes, client previews of works-in-progress, etc.
There are also two different versions of signed apks.
By default, your IDE will sign your apk with a debug key, which will allow users to install it on their device if they check the "use for development" boxes in the Settings.
In order to publish to the marketplace, you have to sign it with a release key, which allows users to install it without enabling additional settings.
You can't publish an unsigned .apk. The Android devloper console won't let you.