How can I create APK file in Android Studio?

How can I create APK file in Android Studio? : In the menu bar , click Build > Generate Signed Bundle/APK In the Generate Signed Bundle or APK dialog, select Android App Bundle or APK and click Next Below the field for Key store path, click Create new On the New Key Store window, provide the following information for your keystore and key, as shown in figure 2

Read Detail Answer On How can I create APK file in Android Studio?

Building and running your app is necessary if you want to see how it functions and appears on a device . You can easily deploy your app to a virtual or physical device with just a few clicks thanks to the way Android Studio sets up new projects.

This overview focuses on how to use Android Studio to build and run your app for the purposes of testing and debugging. For information on how to use Android Studio to build your app so that it can be released to users, seeBuild your app for release to users. For more detailed information about managing and customizing your build, with or without Android Studio, see Configure your build.

Basic build and run

To build and run your app, follow these steps:

  • In the toolbar, selectyour app from the run configurations drop-down menu.
  • From the target device drop-down menu, select the device that you want to run your app on.

    If you don’t have any devices configured, then you need to either create an Android Virtual Device to use theAndroid Emulator or connect a physical device.

  • Click Run .

  • Android Studio will warn you if you attempt to launch your project to a device that has an error or a warning associated with it.Iconography and stylistic changes differentiate between errors (device selections that result in a broken configuration) and warnings (device selections that may result in unexpected behavior but are still runnable).

    Monitor the build process

    You can view details about the build process by clicking View > Tool Windows > Build (or by clicking Build in the tool window bar). The window displays the tasks that Gradle executes in order to build your app, as shown in figure 1.

    Figure 1. The Build output window in Android Studio

  • Build tab: Displays the tasks Gradle executes as a tree, where eachnode represents either a build phase or a group of task dependencies. If you receive build-time or compile-time errors, inspect the tree and select an element to read the error output, as shown in figure 2.

    Figure 2. Inspect the Build output window for error messages

  • Sync tab: Displays tasks that Gradle executes to sync with your project files.Similar to the Build tab, if you encounter a sync error, select elements in the tree to find more information about the error.
  • Restart: Performs the same action as selecting Build > Make Project by generating intermediate build files for all modules in your project.
  • Toggle view: Toggles between displaying task execution as a graphical tree and displaying more detailed text output from Gradle—this is the same output you see in the GradleConsole window on Android Studio 3.0 and earlier.
  • If your build variants use product flavors, Gradle also invokes tasks to build those product flavors. To view the list of all available build tasks, click View > Tool Windows > Gradle (or click Gradle in the tool window bar).

    If an error occurs during the build process, Gradle may recommend some command-line options to help you resolve the issue, such as --stacktrace or --debug. To use command-line options with your build process:

  • Open the Settings or Preferences dialog:
    • On Windows or Linux, select File > Settings from the menu bar.
    • On Mac OSX, select Android Studio > Preferences from the menu bar.
  • Navigate to Build,Execution, Deployment > Compiler.
  • In the text field next to Command-line Options, enter your command-line options.
  • Click OK to save and exit.
  • Gradle applies these command-line options the next time you try building your app.

    Advanced build and run features

    The default way your app is deployed by Android Studio, covered in the preceding section, shouldbe sufficient to test a simple app. For more advanced use cases, you can toggle various aspects of how your app is built and run:

    • You can deploy your app in debug mode by clicking Debug . Running your app in debug mode allows you to set breakpoints in your code, examine variables and evaluate expressions at run time, and run debugging tools. To learn more, seeDebug your app.

    • If you have a larger, more complex app, using Apply Changes instead of clicking Run can save you time because you can avoid restarting your app every time you want to deploy a change. For more information about Apply Changes, see Deploy incrementally with Apply Changes on this page.

    • If you’re using Compose, Live Edit allows you to update composables in real time, without re-clicking Run, so you can focus on writing UI code with minimal interruption. For more information, see Live Edit on this page.

    • If you have an app with multiple build variants, or versions, you can choose which build variant to deploy by using the Build Variants toolwindow. For more information about running a specific build variant, see Change the build variant on this page.

    • To fine tune app installation, launch, and test options, you can change the run/debug configuration. The run/debug configuration specifies whether to deploy your app from an APK or an Android AppBundle, the module to run, package to deploy, activity to start, target device, emulator settings, logcat options, and more. For more information on how to create custom run/debug configurations, see Create run/debug configurations.

    • You should try using Android Studio for your development needs, but you can also deploy your app to a virtual or physical device from the commandline. For more information, see Build your app from the command line.

    Deploy incrementally with Apply Changes

    In Android Studio 3.5 and higher, Apply Changes lets you push code and resource changes to your running app without restarting your app—and, in some cases, without restarting the current activity.This flexibility helps you control how much of your app is restarted when you want to deploy and test small, incremental changes while preserving your device’s current state. Apply Changes uses capabilities in the Android JVMTI implementation that are supported on devices running Android 8.0 (API level 26) or higher. To learn more about how Apply Changes works, seeAndroid Studio Project Marble: Apply Changes.


    Apply Changes actions are only available when you meet the following conditions:

    • You build the APK of your app using a debug build variant.
    • You deploy your app to a target device or emulator that runs Android 8.0 (API level 26)or higher.

    Use Apply Changes

    Apply Changes and Restart Activity are the options to use when deploying your changes to a compatible device.

    Restarting your activity will try to apply your resource and code changes without restarting your app. Usually, you can use this option after making changes to existing resources or the code within a method’s body.

    You can also perform this action by pressing Ctrl+Alt+F10 (or Control+Shift+Command+R on macOS).

    Apply Code Changes

    Attempts to apply only your code changes without restarting anything. Generally, you can use this option when you’vemodified code in the body of a method but you have not modified any resources. If you’ve modified both code and resources, use Apply Changes and Restart Activity instead.

    You can also perform this action by pressing Ctrl+F10 (or Control+Command+R on macOS).


    Deploys all changes and restarts the app. Use this option when the changes that you have madecannot be applied using either of the Apply Changes options. To learn more about the types of changes that require an app restart, see Limitations of Apply Changes.

    Enable Run fallback for Apply Changes

    After you’ve clicked either Apply Changes and Restart Activity orApply Code Changes, Android Studio builds a new APK and determines whether the changes can be applied. If the changes can’t be applied and would cause Apply Changes to fail, Android Studio prompts you to Run your app again instead. However, if you don’t want to be prompted every time this occurs, you can configure Android Studio to automatically rerun your app when changes can’tbe applied.

    To enable this behavior, follow these steps:

  • Open the Settings or Preferences dialog:

    • On Windows or Linux, select File > Settings from the menu bar.
    • On macOS, select Android Studio > Preferences from the menu bar.
  • Navigate to Build, Execution, Deployment > Deployment.

  • Select the checkboxes to enable automatic Runfallback for either of the Apply Changes actions.

  • Click OK.

  • Platform-dependent changes

    Some features of Apply Changes depend on specific versions of the Android platform. To apply these kinds of changes, your app must be deployed to a device running that version of Android (or higher).

    Type of changeMinimum platform version

    Adding a method Android 11

    Limitations of Apply Changes

    Apply Changes is designed to speed up the app deployment process. However, there are some limitations for when it can be used. If you encounter any issues while using Apply Changes, file a bug.

    Code changes that require app restart

    Some code and resource changes cannot be applied until the app is restarted, including the following:

    • Adding or removing a field
    • Removing a method
    • Changing method signatures
    • Changing modifiers of methods or classes
    • Changing class inheritance
    • Changing values in enums
    • Adding or removing a resource
    • Changing the app manifest
    • Changing native libraries (SO files)
    Libraries and plugins

    Some plugins and libraries modify your app’s manifest files or resources that it references without your knowledge. The following are some ways that these automatic updates may cause Apply Changes to fail:

    By turning off all automatic updates for your debug build variants, you can get around these restrictions.

    For example, Crashlytics updates app resources with a unique build IDduring every build, which prevents you from using Apply Code Changes and requires you to restart your app’s activity to see your changes. You can disable this behavior so that you can use Apply Code Changesalongside Crashlytics with your debug builds.

    Code that directly references content in an installed APK

    If your code directly references content from your app’s APK that’s installed on the device, that code can cause crashes or misbehave after clicking Apply Code Changes. This behavior occurs because when you click Apply Code Changes, the underlying APK on the device is replaced during installation. In these cases, you can click Apply Changes and Restart Activity or Run , instead.

    READ More:  How To Fix The Cycle: Frontier Crashing on PC

    Live Edit (experimental)

    Live Edit is an experimental feature that lets you update composables in emulators and physical devices in real time in Android Studio Electric Eel canary releases. When you modify a composable function, your changes are immediately implemented in your device or emulator. By reducing the number of context switches between writing and developing your app, this feature enables you to write code uninterrupted for longer periods of time.

    Live Edit is focused on UI- and UX-related code changes Method signature updates, the addition of new methods, and class hierarchy changes are not supported by Live Edit. Limitations provides additional details.

    This function does not take the place of building, launching, or applying changes to your application. Instead, it’s intended to improve your workflow as you build, deploy, and iterate on Compose UI.

    The best practice workflow is as follows:

  • Set up your application so that itcan be Run.
  • Live Edit as much as possible, until you need to make a change that Live Edit doesn’t support–for example, adding new methods while the app is running.
  • After you make an unsupported change, Run your app to resume Live Editing.
  • Figure 3. Each time you make an edit that is supported byLive Edit, the running app on your device or emulator is updated in real time.

    Get started with Live Edit

    To quickly get started, follow these steps to create an empty Compose Activity, enable Live Edit for your project, and make changes with Live Edit.

    Set up your new project
  • Before you begin, ensure that you have the latest canaryversion of Android Studio Electric Eel installed, and that the API level of your physical device or emulator is at least 30.

  • Open Android Studio and select New Project in the Welcome to Android Studio popup. If you already have a project open, you can create a new one by navigating to File > New > New Project.

  • Choose the Empty Compose Activity template forPhone and Tablet, and then click Next.

    Figure 4. Templates you can choose from. For Live Edit, choose Empty Compose Activity.

  • Enter the following, and then click Finish.

    • Name: HelloWorld
    • Package name:com.example.helloworld
    • Save location: Default.
    • Language: Kotlin
    • Minimum SDK: Default

    Figure 5. Example project settings.

  • Enable LiveEdit
  • In the IDE, navigate to the settings to enable Live Edit.

    • On Windows or Linux, navigate to File > Settings > Editor > Live Edit.
    • On macOS, navigate to Android Studio > Preferences > Editor > Live Edit.

    Figure 6. Select the Live Edit option from the settings.

  • In the editor, open the MainActivity file, which is the entry point for your app.

  • Click Run to deploy your app, andthen click Split on the top right of the editor to open the preview.

  • After you turn on Live Edit, you should see the Live Edit green checkmark on the top right of the editor.

  • Make and review changes

    In the editor, change the existingGreeting method in MainActivity to the following. Your changes appear instantaneously, as shown in figure 7.

    @Composablefun Greeting(name: String) {    Text(text = "Hello $name!",        Modifier.padding(80.dp) // Outer padding; outside background            .background(color = Color.Cyan) // Solid element background color            .padding(16.dp) // Inner padding; inside background, around text)    )}

    Figure 7. Live Edit changes to the Greeting method above appear instantly.


    If you don’t see youredits in the preview pane, Android Studio might have failed to update your edits. Check if the Live Edit UI indicator shows a paused icon, which indicates a compilation error.

    Figure 8. To see more information about the error and suggestions for how to resolve it, hover over Live Edit: ON in the UI.


    The following is a list of current limitations.

    • Live Edit requires a physical device or emulator that is running API level 30 or higher.
    • Live Edit only supports editing a function body, which means that you can’t change the function name or the signature, add or remove a function, or change non-function fields.
    • Live Edit-modified classes might incur some performance penalty. We recommend that you Run your appand use a clean Release build if you are evaluating its performance.
    • You must perform a full Run in order for the debugger to operate on classes that you have modified with Live Edit.
    • A running app might crash when you edit it with Live Edit. If this happens, you can redeploy the app with the Run button.
    • Live Edit doesn’t perform any bytecode manipulation that’s defined in your project’s build file–for example, bytecode manipulation that would be applied when the project is built using the options in the Build menu or by clicking the Build or Run buttons.
    • Non-Composable functions are updated live on the deviceor emulator and a full recomposition is triggered. The full recomposition might not invoke the updated function. For non-composable functions, you must trigger the newly updated functions, or Run the app again.
    • Live Edit doesn’t resume on app restarts. You must Run the app again.

    Frequently asked questions

    • What is the current status of Live Edit?
      • Live Edit is available in the AndroidStudio Electric Eel canary channel as an experimental feature. You can turn it on or off by navigating to File > Settings > Editor > Live Edit (Android Studio > Preferences > Editor > Live Edit on macOS).
    • When should I use Live Edit?
      • Use Live Edit when you want to quickly see the effect of updates to UX elements (e.g.modifier updates, animations) on the overall app experience.
    • When should I avoid using Live Edit?
      • Live Edit is currently focused on UI- and UX-related code changes. Avoid using it for changes such as method signature updates, adding new methods, or class hierarchy changes, which it does not support. For more information, see Limitations.
    • When should I use ComposePreview?
      • Use Composition Preview when you’re developing individual composables. Preview visualizes Compose elements and automatically refreshes to display the effect of code changes. Preview also supports viewing UI elements under different configurations and states (for example dark mode, locales, font scale).

    Change the build variant

    By default, Android Studio builds the debug version of your app,which is intended for use only during development, when you click Run.

    To change the build variant Android Studio uses, select Build > Select Build Variant in the menu bar.

    For projects without native/C++ code, the Build Variants panel has two columns: Module and Active Build Variant. The Active Build Variant value for the module determines which build variant the IDEdeploys to your connected device and is visible in the editor.

    Figure 9. The Build Variants panel has two columns for projects that do not have native/C++ code

    To switch between variants, click the Active Build Variant cell for a module and choose the desired variant from the list field.

    For projects with native/C++code, the Build Variants panel has three columns: Module, Active Build Variant, and Active ABI. The Active Build Variant value for the module determines the build variant that the IDE deploys to your device and is visible in the editor. For native modules, the Active ABI value determines the ABI that the editor uses, butdoes not impact what is deployed.

    Figure 10. The Build Variants panel adds the Active ABI column for projects with native/C++ code

    To change the build variant or ABI, click the cell for the Active Build Variant or Active ABI column and choose the desired variant or ABI from the list.After you change the selection, the IDE syncs your project automatically. Changing either column for an app or library module will apply the change to all dependent rows.

    Two build variants—a debug and a release variant—are automatically configured for new projects. To get your app ready for a general release, you must build the release variant.

    You can define additional build variants to build different versions of your app, each with unique features or device specifications.

    Conflicts in Android Studio’s Build Variants dialog

    You may see error messages like the ones below in the Android Studios Build Variants dialog indicating conflicts between build variants.

    This error only signifies that the Android Studio IDE itself is unable to resolve symbols between the variants of the chosen modules and does not suggest a problem with Gradle’s build process.

    For example, if you have a module M1 that depends on variant v1 of module M2, but M2 has variant v2 selected in the IDE,you have unresolved symbols in the IDE. Let’s say that M1 depends on a class Foo which is only available in v1. When v2 is selected, that class is not known by the IDE and it will fail to resolve it and show errors in the code of M1.

    These error messages appear because the IDE cannot load code for multiple variants simultaneously. In terms of your app’s build, however, the variant selected in this dialog will have no effect because Gradle builds your app withthe source code specified in your Gradle build recipes, not based on what’s currently loaded in the IDE.

    Change the run/debug configuration

    Android Studio uses a default run configuration when you launch your app for the first time. The run configuration specifies the target device, emulator settings, logcat options, the module to run, package to deploy, activity to start, and more when deploying your app from an APK or an Android App Bundle.

    The default run/debug configuration builds an APK, launches the default project activity, and uses the Select Deployment Target dialog for target device selection. If the default settings don’t suit your project or module, you can customize the run/debug configuration, or even create a new one, at the project, default, and module levels. To edit a run/debugconfiguration, select Run > Edit Configurations. For more information, see Create and Edit Run/Debug Configurations.

    How can I create my own APK? : 5 steps to create an APK fileOpen AppsGeyser. Visit appsgeyser Choose an app for business or one to make money at com/create/start/. Select the App Template. For the kind of app you want, pick a template. abide by the Guide. Give the APK file a name. Pick an icon. Obtain the APK file.
    Can I run an APK in Android Studio? : Alternatively, if a project is already open, choose File > Profile or Debug APK from the menu bar. Select the APK you want to import into Android Studio and click OK in the following dialog box. Android Studio then displays the unpacked APK files, similar to figure 1
    Read Detail Answer On Can I run an APK in Android Studio?

    After successfully obscuring my Android application, I want to test it by installing the APK file and running it on an emulator.

    You can simply drag and drop the .apk file of your application to the emulator and it will automatically start installing.

    Another option:


  • Execute the emulator (SDK Manager.exe->Tools->Manage AVDs…->New then Start)
  • Start the console (Windows XP), Run -> type cmd, and move tothe platform-tools folder of SDK directory.
  • Paste the APK file in the ‘android-sdk\tools’ or ‘platform-tools’ folder.
  • Then type the following command.
  • adb install [.apk path]


    adb install C:\Users\Name\MyProject\build\Jorgesys.apk


  • Copy the apk file to platform-tools in the android-sdk linux folder.
  • OpenTerminal and navigate to platform-tools folder in android-sdk.
  • Then Execute this command –
  • ./adb install FileName.apk

  • If the operation is successful (the result is displayed on the screen), then you will find your file in the launcher of your emulator.
  • READ More:  Viking: Battle for Asgard On Steam Free Download Full Version



    Example : PATH=$PATH:/users/jorgesys/eclipse/android-sdk-mac_64/tools

    Then run adb.


    1.Run the emulator,

    2.then copy your .apk file and paste into /Users/your_system_username/Library/Android/sdk/platform-tools, if you are not able to find sdk path in your mac system, do the following steps: Open finder->select Go option on top menu -> select Go to Folder option -> it will popup a window with a textfield: /Users/your_system_username/Library/Android/sdk/ -> now open platform-tools folder and paste your copied .apk file,

  • Now open the terminal and type the following: cd Library/Android/sdk/platform-tools

  • executethe following in your terminal: ./adb install yourapkfilename.apk if you get the following error message: error: no devices found - waiting for device, follow step 5.

  • Run your emulator from Android Studio, once emulator active then repeat step 4, you will see the success message on your terminal.

  • Leon

    30.2k4 gold badges63 silver badges88 bronze badges

    answered Aug 13, 2010 at 19:50


    121k23 gold badges321 silver badges259 bronze badges


    If you’ve created more than one emulators or if you have an Android device plugged in, adb will complain with

    error: more than one device and emulator

    adb help is not extremely clear on what to do:

    -d                        - directs command to the only connected USB device...-e                        - directs command to the only running emulator...-s <serial number>        ...-p <product name or path> ...

    The flag you decide to use has to come before the actual adbcommand:

    adb -e install path/to/app.apk

    answered Dec 23, 2011 at 14:30


    55.5k12 gold badges53 silver badges59 bronze badges


    Nowadays, you can simply drag and drop the Android apk to the emulator and it will automatically starts installing.

    answered Jun 21, 2016 at 11:27


    5,3454 gold badges31 silver badges51bronze badges


    go to sdk folder, then go to tools.copy your apk file inside the tool directory./emulator -avd myEmulatorto run the emulator on mac ./adb install myApp.apkto install app on the emulator

    answered Aug 13, 2010 at 21:02


    74.1k89 goldbadges289 silver badges435 bronze badges


    go to the android-sdk/tools directory in command prompt and thentype

     adb install fileName.apk (Windows) ./adb install fileName.apk (Linux or Mac)


    1,5882 gold badges19 silver badges34 bronze badges

    answered Oct 17, 2013 at 8:01


    1,8776 gold badges32 silver badges70 bronze badges

    Copy.apk file in your SDK’s platform-tools/ directory,then install the .apk on the emulator by using cmd(on windows):

    adb install <path_to_your_bin>.apk


    ./adb install <path_to_your_bin>.apk

    If there is more than one emulator running, you can find all running emulators by this command:

    adb devices


    ./adb devices

    then you must specify the emulator upon which to install the application, by its serial number, with the -s option. For example:

    adb -s emulator-5554 install path/to/your/app.apk


    ./adb -s emulator-5554 install path/to/your/app.apk

    answeredNov 24, 2014 at 15:05

    Hamed GhadirianHamed Ghadirian

    5,9635 gold badges44 silver badges65 bronze badges

    answeredApr 23, 2018 at 6:42


    1,62918 silver badges20 bronze badges

    Simply drag and drop the * in Genymotion. APK files can be loaded into emulators to automatically install and run them.


    answered Jan 11, 2014 at 13:58


    10.2k25 gold badges91 silver badges160 bronze badges

    Download the Apk file from net and copy it to platform-tools of your SDK folder, then in command prompt go to that directory an type:

    adb install filename.apk

    press enter it will install in few seconds


    23.7k6 gold badges80 silver badges76 bronze badges

    answered Feb 22, 2013 at 12:44


    1411 silverbadge8 bronze badges

    Simply click on the apk file (notification area) after downloading it from your browser. Installation will begin instantly.

    answeredAug 20, 2012 at 11:57


    4204 silver badges14 bronze badges

    Goto Shell/Terminal/, reach at android-sdk/tools directory then

    adb install fileName.apk // (u can run this command on windows)or ./adb install fileName.apk  //( u can run this command on linux)

    answered May 30, 2013 at 4:27


    37.3k12 gold badges114 silver badges111 bronze badges

    Let’s say you need to download and install the Facebook APK on your emulator.

    You can use adb to install the APK to the running emulator in OS X like this:

    ./adb install ~/FBAndroid-2.1.apk

    And on Windows, like this:

    adb install %HOMEPATH%\FBAndroid-2.1.apk

    Once complete, check the apps screen of the emulator to check that the app has been installed correctly. If you need to force the upgrade of this app from a previous version, add the -r flag, like this on OS X:

    ./adb install -r ~/FBAndroid-2.1.apk

    Erick Filho

    1,9523 gold badges18 silver badges31 bronze badges

    answered Apr 11, 2013 at 13:34


    3,65637 silver badges34 bronze badges

    keep your emulator up and running. In the command line, go inside theplatform-tools folder, in your sdk folder which come with adt bundle and execute following command :

    >adb install <yourFilename.apk>

    This command will show you a list of devices where you can install this app and will detect any emulators that are currently running on your computer. It will also indicate whether any physical devices are currently connected to your computer. ) Then you can choose any one; if only one emulator is running, the app will automatically install there.

    Note: Your command for the preceding. APK files must be located in the same directory.

    for moredetailed tutorial follo : This link

    answered Mar 14, 2014 at 9:47


    1,6164 gold badges21 silver badges44 bronze badges

    From Windows 7 Onwards ,

    Shift + Right click in your apk file folder.

    Select Open Command Window Here

    Type & Hit “adb install AppName.apk”

    answered Dec 14, 2014 at 10:27

    Don ChakkappanDon Chakkappan

    7,2515 goldbadges43 silver badges57 bronze badges

    Drag and drop “.apk” file into the emulator window.

    Amir Dora.

    2,7794 gold badges32 silver badges53 bronze badges

    answeredFeb 11, 2018 at 6:00

    Dan AlboteanuDan Alboteanu

    8,3981 gold badge45 silver badges39 bronze badges


    Just drag and dropyour apk to emulator


    7,43113 gold badges40 silver badges67 bronze badges

    answered Oct 6, 2019 at 8:23

    BIS TechBIS Tech

    13.9k8 gold badges76 silver badges118 bronze badges


    The first step is to run the emulator

    emulator -avd < avd_name>

    then use adb to install the .apk

    adb install < path to .apk file>

    If adb throws error like APK already exists or something alike. Run the adb shell while emulator is running

    adb shell

    cd data/app

    adb uninstall < apk file withoutusing .apk>

    If the commands for adb and emulator cannot be found, proceed as follows.

    export PATH=$PATH://android-sdk-macosx/platform-tools://android-sdk-macosx/android-sdk-macosx/tools:

    For future use put the above line at the end of .bash_profile

    vi ~/.bash_profile

    answered Sep 19, 2014 at 12:15


    7047 silverbadges14 bronze badges

    if use more than one emulator at firs use this command

    adb devices

    and then chose amulatur and install application

    adb -s "EMULATOR NAME" install "FILE PATH"adb -s emulator-5556 install C:\Users\criss\youwave\WhatsApp.apk

    answeredMar 30, 2015 at 8:54


    7356 silver badges22 bronze badges

    I might be wrong, but on Windows I simply drag and drop the .apk into Android Emulator. I mean, doingall mentioned above seems to be a lot of work.

    Juri Noga

    4,3237 gold badges36 silver badges49 bronze badges

    answered Jan 31, 2017 at 2:00

    MarceloAgimóvelMarcelo Agimóvel

    1,5882 gold badges17 silver badges25 bronze badges


    go to ADT/Android-sdk/tools directory in command prompt 1. adb install fileName.apk (Windows)

  • ./adb install fileName.apk (Ubuntu/Linux or Mac)
  • answered Jun 13, 2014 at 3:40


    4586 silver badges8 bronze badges


    Drag and Drop didn’t work for me on Windows 10 Pro.

  • Put the APK on Google Drive

  • Access that Google drive using Chrome browser on the Android Emulator

  • Then install it fromthere.

  • Note: You need to enable unknown sources within the Emulator.

    answered Nov 6, 2020 at 17:34


    59.8k57 gold badges285 silver badges417 bronze badges

    To open the apk file on an emulator, the best method is to create an app. Copying is required. apk file to the downloads directory of your emulator. Then swap out yourAppName. with your apk. Name of the apk.

    here is the code

    public class MainActivity extends Activity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        Intent intent = new Intent(Intent.ACTION_VIEW);        intent.setDataAndType(Uri.fromFile(new File(Environment.getExternalStorageDirectory() + "/download/" + "yourAppName.apk")), "application/");        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);        startActivity(intent);    }}


    15.1k9 gold badges53 silver badges75 bronze badges

    answered Feb 11, 2016 at 12:29


    3731 goldbadge4 silver badges10 bronze badges

    (1) You can also use gradle commands to install your APK whilechoosing the product and flavor (Debug or Release). See this Guide.

    ./gradlew assembleDebug (Incase you don't have the APK generated)./gradlew installDebug

    Incase you want a fresh install, you can remove any earlier installed builds on the device with below commands

    ./gradlew uninstallDebug./gradlew installDebug

    (2) You can also use the adb commands directly:

    Setup adb for command line

    export PATH=/Users/mayurik/Library/Android/sdk/platform-tools/adb:/Users/mayurik/Library/Android/sdk/tool

    Command line ADB install

    adb -d install pathto/sample.apk (on device)adb -e install pathto/sample.apk (on emulator)

    Also check the documentation here

    $ adb devicesList of devices attachedemulator-5554 deviceemulator-5555 device$ adb -s emulator-5555 install helloWorld.apk

    answered Sep 9, 2019 at 8:24

    you write the command on terminal/cmd adb install FileName.apk.

    answered Jun 15, 2015 at 12:15

    Now, all you have to do is drag the apk into the emulator, and it will install.

    answered Aug 29, 2017 at 12:36


    On Linux I do this:

  • first see which devices I currently have: emulator -list-avds
  • build the release cd android && ./gradlew assembleRelease
  • install it at the emulated device “Nexus5” (you are inside the android directory, else usethe full path to apk): adb -s '8e138a9c' install app/build/outputs/apk/app-release.apk
  • Thats it. You can also use ./gradlew installRelease

    answered Sep 14, 2017 at 10:21


    11.5k3 gold badges55 silver badges93 bronze badges

    Follow the steps :

  • make sure you have allowed installation from unknown sources in settings.
  • Use the Android Device Monitor to copy the APK to the sdcard.
  • Use the builtin browser in Android to navigate to file:///sdcard/apk-name.apk
  • When the notification “Download complete” appears, click it.
  • answered Sep 8, 2016 at 20:12

    1) paste the myapp.apk in platform-tools folder , in my case C:\Users\mazbizxam\AppData\Local\Android\android-sdk\platform-tools, this is the link in my case it may change to you people

    2)openthe directory in CMD CD C:\Users\mazbizxam\AppData\Local\Android\android-sdk\platform-tools

    3)Now you are in platform-tools folder , just type adb install myapp.apk

    Make sure your emulator is turned on; if everything is in order, an apk will install.

    answered Apr 20, 2016 at 5:23


    3284 silver badges19 bronze badges

    Start the console (Windows XP), Run -> type cmd, and move to the platform-tools folder of SDK directory.

    In case anyone wondering how to run cmd in platform-tools folder of SDK directory, if you are running a new enough version of Windows, follow the steps:

  • Go to platform-tools through Windows Explorer.
  • While holding shift right click and you will find the option “Open Command windowhere”.
  • Click on it and cmd will start in that folder.
  • Hope it helps

    answered May 30, 2016 at 13:16


    13.7k6 gold badges51 silver badges68 bronze badges

    Not the answer you’re looking for? Browse other questions tagged android android-emulatorinstallation apk or ask your own question.

    Where is the APK generated in Android Studio? : \build\production\MyProject. apk, and true enough, there is no . apk file at that location, or indeed anywhere else in the project filesystem.
    Read Detail Answer On Where is the APK generated in Android Studio?
    READ More:  Stationeers: Human Cosmetics Pack On Steam Free Download Full Version

    First are the debug APK files that are generated solely for testing purposes. They will run on your Android mobile. However, they cannot be uploaded to the Play Store or made available to the public.

    Secondly, you can generatesigned APK files. Signed APK files come in handy when you’ve tested your application and it is ready to be uploaded on the Play Store and released to the general public.

    First things first: open up a project file in Android Studio. If you don’t have a project file yet, simply create aNew Project.

    Creating an APK file

    First, open up your project or application that you want to import into an APK file. Then, select Build > Build Bundle(s)/APK(s) > Build APK(s) from the toolbarmenu.

    The generation of an APKfile by Android Studio will take some time.

    Once the APK build is complete, you’ll receive a notification on the bottom right corner of your screen. From that notification, select Locate and you will be led to the APK file location.

    If you miss the notification, you can still locate the APK file in the following path within your projectfolder: app/build/outputs/apk/debug. The file is named app-debug.apk by default.

    Creating a Signed APK File

    To generate a signed APK file, open the Build menu from the toolbar and select Generate Signed Bundle/APK.

    Thisopens up a screen where you have to select between creating an Android App Bundle and creating an APK file. Check the APK radio button and proceed to the next window.

    In the next window, you will be shown the module (your application) for which the APK file is being generated. You’ll be asked about yourKey store path, Key store password, Key alias, and the Key password.

    Creating a New Key Store

    Assuming that this is the first time you’re creating a Signed APK file, you will have to create a new key store.

    Once an application has been uploaded to the Play Store, the developer can access it using keys. The need for the keys typically arises when you need to update your application. The key store houses all of the available keys.

    Keys and the key store are both secured by unique passwords. A minimum of six characters must be used in the passwords. Also, it is a good practice to keep multiple copies of your keys since they are your only gateway to your application You won’t be able to update or access your application if the key is lost.

    Creating your ownapp requires you to create a new key store. To do so, select Create new. You will find it underneath the input field where you enter the key store path.

    You will then be redirected to a new window.

    Enter the path to your new key store in the new window before adding a password to secure it.

    You’ll also be creating a new key for your application in the same window. In the key alias field, enter an identity for your key before entering a password for it.

    Although it’s a good idea to give each of your keys a new password, you can keep the same password as the one for your key store. For the key alias, the same holds true.

    The validity of your application is specified in the following field. This is the time frame after which your application’s key will expire and become inoperable. A key’s default lifespan is 25 years.

    For each key that you generate, you’re given a certificate that contains all the information about you and your company. You don’t necessarily have to fill in all the details—just choose the ones you think should go on your certificate. A key will still be generated, even without filling in each field of the certificate.


    Once you have filled in the details for the certificate, select OK. You will then be directed back to the Generate Signed Bundle or APK screen.

    Here, all of the fields will now be pre-filled for you. Go through all the details to stay on the safe side. Then, select Next.

    On the last screen, you will now be able to see the destination of your Signed APK file. Below that, you will see two more options: Debug andRelease.

    Debugging is used when the application is still in the testing phase. Since your application has passed the testing phase and is ready for deployment, select Release.

    There are two more checkboxes towards the bottom of the screen. Select V2 (Full APK Signature) and click Finish.

    You will be notified by Android Studio once the APK build is finished. Now, you can click on Locate from the notification to open up the filelocation.

    The Signed APK file is named app-release.apk by default. You will find it in your project folder in the app/release directory.  


    These are the steps you need to follow to generate APK and Signed APK files for the purposes of testing your app and making it downloadable via Google Play respectively:

    Create an APK File

  • Create the project in AndroidStudio.
  • Select Build > Build Bundle(s)/APK(s) > Build APK(s) from the toolbar menu.
  • You can now transfer your debug APK file to your Android mobile phone and test it for bugs. You can also test it out on your PC using the Android emulator.

    Create a Signed APK File

  • Create the project in Android Studio.
  • Select Build > Signed Bundle/APK from the toolbarmenu.
  • Configure the settings for your APK file and possibly create a new key store and key.
  • Create a New Key Store and Key

  • Select a key store path.
  • Enter a password for your key store.
  • Give your key an identity, validity period, and password.
  • Enter any personal or organizational details you want included in the key certificate.
  • By posting it on Google Play Store, you can now make this signed APK file available to the general public.

    Hopefully, this tutorial helped to clear up any misunderstandings you may have had regarding the generation of APK and signed APK files and improved your understanding of both file types.

    Did you find this post useful?

    Freelance Content Writer

    Writer of content on the side, Arooha Arif. Although she excels at writing copy, she prefers long-form content articles and blogs over all other types of writing. This is primarily due to the author’s conviction that long-form content is the most valuable asset because it benefits users while also enhancing a company’s or brand’s credibility. Writing tech tutorials for Envato is Arooha’s sole focus. She became interested in technology after starting a book blog in high school. Since then, she has learned to code and is now able to research and address any technological challenge she encounters in her work as a full-time freelance writer. English literature is Arooha Arif’s area of passion and her major. She reads classic books or Rilke poetry when she isn’t writing. According to her, reading an article should be a pleasant and appealing experience for the reader as well as something that adds value. Her expertise extends far beyond tech. In addition, she enjoys writing content about SaaS, marketing, and personal development. Her email address is aruha, so you can get in touch with her there. [email protected] com.

    Additional Question — How can I create APK file in Android Studio?

    What is APK full form?

    APK stands for Android Application Package in its full form. The application file format used by Android, as well as a large number of other Android-based operating applications in smartphones, video games, and middleware, is called an APK.

    How can I create an Android application?

    Create a new project in Android Studio in step one. Start a new Android Studio project can be selected from the Welcome to Android Studio dialog box. Instead of the default, choose Basic Activity. Name your program something like My First App. Ensure that Java is selected under Language. For the other fields, leave the default values in place. Select Finish.

    Where is signed APK location?

    The signed apk is put right into the module’s folder where it was built in the new Android Studio.

    What is Keystore path in Android Studio?

    The default location is located at /Users. android/debug. keystore.

    How do I get APK files from installed apps?

    Copy the URL of the app you want to extract from the Google Play Store. The next step is to paste the URL into this web tool in your browser. Choosing Generate Download Link. Once the APK file has been automatically extracted, this web application will give you the necessary link to access it.

    How does an APK work?

    A program for Android must be first compiled using a program like Android Studio or Visual Studio before all of its components are assembled into a single container file to create an APK file. All of a program’s code, including that for, is contained in an APK file. resources, assets, certificates, and manifest files (.dex files).

    Are APK files legal?

    Downloading APK files and using them to install apps not found in the Google Play Store is entirely legal. Just like EXE or ZIP, APK is a file format. The APK file format was created by Google, but anyone can produce and use APK files.

    What is the difference between APK and app?

    While APK (Android application Package) is the packaging format that will ultimately be installed on the device, app bundles are the publishing format. For each user’s device configuration, Google uses app bundle to generate and serve optimized APKs, ensuring that users only download the resources and code required to run your app.

    What opens APK?

    APK file opening applicationsGoogle Android bundled with OS. ZArchiver by ZDevs Android Studio by Google. Android Debugging Bridge BlueStacks Android Studio by Google. Android Debugging Bridge A utility from Apple. Linux. Search Engine Android Studio Android Debug Bridge. Web. ApkOnline. Appetize io Chrome OS Search Engine Android Studio

    Is APK file safe?

    The APK files can be extremely dangerous to your system’s security because they install apps. Before you install it, the APK could be altered by someone with malicious intentions, who would then use it as a Trojan horse on the internet to download and execute malware. As a result, you must make sure the website you use is reputable.

    Why do we use APK file?

    Installing apps on an Android device is made possible by APK files. They are comparable to the package files used on other platforms and the APPX files used to install Store apps on Windows 10.

    Dannie Jarrod

    Leave a Comment