Most Frequently asked Interview Questions of android-studio(2024)

Question: How do you integrate third-party libraries or SDKs into an Android project in Android Studio?

Answer:

Integrating third-party libraries or SDKs into an Android project is a common practice to extend the functionality of your app without having to reinvent the wheel. Android Studio provides a streamlined way to include these external dependencies into your project using Gradle.

Here’s a step-by-step guide on how to integrate third-party libraries or SDKs:

---

1. Using Gradle (Maven Central / JCenter / JitPack / etc.):

Most modern Android libraries are hosted on repositories such as Maven Central, JCenter, or JitPack. You can easily add these dependencies by modifying the build.gradle file.

Steps:

1. Open your project in Android Studio.

2. Locate the build.gradle file (usually in the app directory).

   For example:

   app/
       build.gradle

3. Add the library dependency inside the dependencies block of the build.gradle (Module: app) file. You’ll typically find the required dependency version and format in the documentation of the third-party library.

   Example for adding a Retrofit library:

   dependencies {
       implementation 'com.squareup.retrofit2:retrofit:2.9.0'
       implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
   }

   Note: The implementation keyword is commonly used for dependencies in modern Android development. If the library is needed at compile time but not runtime, you can use api or compileOnly.

4. Sync your project by clicking Sync Now in the prompt that appears in Android Studio, or by selecting File > Sync Project with Gradle Files.

   This step will download the library and resolve any dependencies automatically.

---

2. Adding an SDK (e.g., Firebase, Google Maps, etc.):

Some SDKs, like Firebase or Google Maps, require additional steps beyond just adding a dependency. These often involve including configuration files (e.g., google-services.json for Firebase) and adding plugins or additional repositories.

Steps for Firebase SDK Integration (Example):

1. Add the Firebase SDK dependency in the build.gradle file.

   • Add the classpath in the build.gradle (Project-level) file:

     buildscript {
         repositories {
             google()
             mavenCentral()
         }
         dependencies {
             classpath 'com.google.gms:google-services:4.3.10' // Firebase plugin
         }
     }

2. Add Firebase dependencies in the build.gradle (Module-level) file:

   dependencies {
       implementation 'com.google.firebase:firebase-auth:21.0.1'
       implementation 'com.google.firebase:firebase-database:20.0.3'
   }

3. Download and configure the google-services.json file from the Firebase console:

   • Go to the Firebase Console, select your project, and download the google-services.json file.
   • Place the file in the app/ directory of your project.

4. Apply the Google Services plugin at the bottom of your build.gradle (Module-level) file:

   apply plugin: 'com.google.gms.google-services'

5. Sync your project by clicking Sync Now.

---

3. Using JitPack for GitHub Libraries:

For libraries hosted on GitHub or other Git-based repositories, you can use JitPack, which builds the library directly from GitHub repositories.

Steps for integrating a GitHub library using JitPack:

1. Add JitPack repository in the repositories section of the build.gradle (Project-level) file:

   allprojects {
       repositories {
           google()
           mavenCentral()
           maven { url 'https://jitpack.io' }
       }
   }

2. Add the dependency for the library in the build.gradle (Module-level) file. Use the specific version or commit hash:

   dependencies {
       implementation 'com.github.User:Repo:Tag'
   }

   Example:

   dependencies {
       implementation 'com.github.bumptech.glide:glide:4.12.0'
   }

3. Sync your project by clicking Sync Now.

---

4. Manually Adding Local JAR/AAR Files:

If the third-party library is not available in a public repository, or if you have a local .jar or .aar file, you can manually add it to your project.

Steps for adding a .jar or .aar file:

1. Create a libs directory in your app folder if it doesn’t already exist.

   • Right-click on the app folder, select New > Directory, and name it libs.

2. Copy the .jar or .aar file into the libs folder.

3. Modify the build.gradle (Module-level) file to include the .jar or .aar file:

   dependencies {
       implementation files('libs/library-name.jar')
   }

   For .aar files:

   dependencies {
       implementation(name: 'library-name', ext: 'aar')
   }

4. Sync your project by clicking Sync Now.

---

5. Using Android Studio’s Built-In Dependencies:

Android Studio has built-in support for integrating popular third-party libraries with its Android Support Library or Jetpack libraries.

Steps:

1. Search for the library in the Android Studio’s Dependencies window.

   • Go to File > Project Structure.
   • Under the Dependencies tab, click the + button to add a new dependency.
   • Select Library dependency and search for the library.

2. Sync your project after adding the dependency.

---

Best Practices for Managing Dependencies:

1. Use Versions: Always specify versions of third-party libraries to ensure your project remains compatible and stable.
2. Avoid Dependency Conflicts: Be mindful of version conflicts between dependencies. Use resolutionStrategy in Gradle to manage these.
3. Minimize Unnecessary Libraries: Only add libraries that you really need. Each added dependency increases the size of your app.
4. Use Proguard/R8: When you’re ready for production, make sure to minify and obfuscate third-party libraries to remove unused code and improve security.

---

Summary of Integration Methods:

• Gradle Dependencies: Add libraries from repositories like Maven Central or JCenter by adding the dependency to build.gradle.
• SDK Integration: For SDKs like Firebase, you may need to configure additional steps like downloading a configuration file and applying plugins.
• JitPack: Use JitPack to integrate GitHub-hosted libraries.
• Manual .jar/.aar Files: Manually add .jar or .aar files if the library is not available in a public repository.
• Android Studio Built-In Tools: Use Android Studio’s built-in features for integrating common libraries.

By following these methods, you can easily integrate third-party libraries or SDKs into your Android Studio project.

Question: Explain the concept of Gradle build scripts and how they are used in Android Studio.

Answer:

Gradle is the default build automation tool used by Android Studio for compiling, testing, and packaging Android apps. The Gradle build script is a crucial part of this process, and it defines how an Android project is built, including which dependencies are included, the build types, and the configuration of different build variants. Gradle is highly flexible and allows developers to automate tasks such as code compilation, testing, packaging, and deployment.

Gradle Build Scripts Overview:

Gradle build scripts are written in Groovy or Kotlin DSL. They are used to define how the Android project should be built and how dependencies should be resolved. The build scripts are generally divided into two main files in Android Studio:

1. Project-level build.gradle: This file contains global settings that apply to the entire project, including repository configurations, plugins, and dependencies that affect all modules in the project.
2. Module-level build.gradle (e.g., app/build.gradle): This file is specific to each module in the project (such as the app module) and defines things like dependencies, build configurations, flavors, and types.

---

1. Project-Level build.gradle File:

The project-level build.gradle file is located in the root directory of your project (e.g., MyProject/build.gradle). It applies global settings for the entire project.

Key components of the project-level build.gradle:

• Repositories: Where Gradle looks for external dependencies (like Maven, JCenter, Google, etc.)

  buildscript {
      repositories {
          google()        // Google repository
          mavenCentral()  // Maven central repository
          jcenter()       // JCenter repository (deprecated, but used in legacy apps)
      }
      dependencies {
          // Define classpaths for plugins
          classpath 'com.android.tools.build:gradle:7.0.2' // Android Gradle Plugin
          // Other classpaths for different plugins
      }
  }
  
  allprojects {
      repositories {
          google()
          mavenCentral()
      }
  }

• Dependencies: Defines build script dependencies, such as the Android Gradle plugin, and any other global dependencies needed for building the project.

---

2. Module-Level build.gradle File:

The module-level build.gradle file (e.g., app/build.gradle) is where you define the configuration for individual modules. For Android projects, the most common module is the app module, which contains the source code, resources, and Android-specific configurations.

Key components of the module-level build.gradle:

a. Plugins Block:

The plugins block applies the necessary plugins, such as the Android plugin for Gradle, which provides tasks for building Android apps.

plugins {
    id 'com.android.application' // For Android app modules
    id 'kotlin-android'          // For Kotlin support
}

b. Android Block:

This is where you define Android-specific settings for the module, such as the compileSdkVersion, defaultConfig, buildTypes, and flavors.

android {
    compileSdkVersion 30 // The SDK version to compile against

    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 16  // Minimum supported SDK version
        targetSdkVersion 30  // The SDK version to target
        versionCode 1     // Internal version code
        versionName "1.0" // User-visible version name
    }

    buildTypes {
        release {
            minifyEnabled false // ProGuard or R8 code shrinking
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }

    flavorDimensions "version"
    productFlavors {
        free {
            applicationIdSuffix ".free" // For free version
        }
        paid {
            applicationIdSuffix ".paid" // For paid version
        }
    }
}

c. Dependencies Block:

This is where you define all the dependencies for your module, such as libraries or SDKs required for building and running the app.

dependencies {
    implementation 'com.android.support:appcompat-v7:30.0.0'
    implementation 'com.squareup.retrofit2:retrofit:2.9.0' // Retrofit library for API calls
    implementation 'com.google.firebase:firebase-analytics:19.0.0' // Firebase SDK
    testImplementation 'junit:junit:4.13.2' // Unit testing library
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0' // UI testing library
}

• implementation: Specifies that a dependency is required for compiling and running the app.
• testImplementation: Specifies that a dependency is required only for unit tests.
• androidTestImplementation: Specifies dependencies for Android instrumented tests (UI tests).

---

3. Gradle Tasks:

Gradle builds are driven by tasks. Each task represents a specific step in the build process, such as compiling source code, running tests, or creating the APK.

Examples of Gradle tasks:

• gradle build: Builds the entire project.
• gradle assembleRelease: Builds the release APK or AAB (Android App Bundle).
• gradle clean: Cleans the project by removing build artifacts.
• gradle test: Runs unit tests.
• gradle connectedAndroidTest: Runs Android instrumentation tests on a connected device.

---

4. Managing Multiple Build Variants:

Gradle allows you to create build variants for different versions of your app (e.g., free vs. paid, debug vs. release). These variants are configured using product flavors and build types.

Example:

android {
    buildTypes {
        debug {
            buildConfigField "String", "API_URL", "\"https://dev-api.example.com\""
            applicationIdSuffix ".debug"
            versionNameSuffix "-debug"
        }
        release {
            buildConfigField "String", "API_URL", "\"https://api.example.com\""
            minifyEnabled true
        }
    }

    productFlavors {
        free {
            dimension "version"
            applicationIdSuffix ".free"
            versionNameSuffix "-free"
        }
        paid {
            dimension "version"
            applicationIdSuffix ".paid"
            versionNameSuffix "-paid"
        }
    }
}

In this case, Gradle will create different build variants:

• freeDebug
• freeRelease
• paidDebug
• paidRelease

Each variant can have its own settings, such as different API URLs, version codes, or application IDs.

---

5. Gradle Wrapper:

The Gradle Wrapper is a script that allows you to run Gradle builds without needing to manually install Gradle. It ensures that everyone working on the project is using the same version of Gradle.

The wrapper is configured in your project with files like gradlew (Linux/Mac) and gradlew.bat (Windows), and gradle/wrapper/gradle-wrapper.properties.

Example of the wrapper configuration in gradle-wrapper.properties:

distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-bin.zip

---

6. Gradle Build Configuration for Android Studio:

In Android Studio, Gradle tasks and build configurations are tightly integrated. The IDE uses Gradle to:

• Compile your source code.
• Package the app into APK or AAB.
• Run unit tests and instrumentation tests.
• Create build variants for different product flavors and build types.

You can run Gradle tasks directly from Android Studio using the Gradle Tool Window (on the right side) or through the Terminal.

---

Summary:

Gradle build scripts in Android Studio automate the process of building, testing, and deploying Android applications. The key components of a Gradle build script are:

• Project-level build.gradle for global configurations.
• Module-level build.gradle for specific configurations, dependencies, and build variants.
• Gradle tasks to perform various build and test operations.
• Multiple build variants to manage different versions of the app.
• Gradle Wrapper to ensure consistent build environments.

By understanding and modifying Gradle build scripts, developers can fine-tune the build process, manage dependencies, and configure advanced features like product flavors, custom build types, and much more.

Question: How do you handle Android application versioning and signing in Android Studio?

Answer:

In Android development, versioning and signing are essential for managing app releases, ensuring security, and keeping track of different versions of the app. Android Studio provides built-in tools and configurations to handle both.

1. Android Application Versioning

Versioning involves setting version code and version name in the build.gradle file. These are used to distinguish between different releases of the application.

• Version Code: An integer value that represents the version of the app. This value must be incremented with each new release. It is used by the Android system to differentiate between versions of the app, especially when updating the app.

• Version Name: A string value that represents the human-readable version of the app (e.g., 1.0.0, 2.1.1). It is shown to users in the app store and in the app’s settings.

How to Set Versioning:

In the module-level build.gradle (e.g., app/build.gradle), you can define these values in the defaultConfig block:

android {
    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 16
        targetSdkVersion 30
        
        versionCode 1     // Increment this value for each new release
        versionName "1.0" // Set a human-readable version name
    }
}

• Version Code: Should be an integer, and each release (including beta versions) should have a higher number than the last release.

• Version Name: Typically follows semantic versioning conventions (major.minor.patch). For example, 1.0.0, 1.1.0, or 1.0.1.

2. Android Application Signing

App signing is a critical step in the Android development process. It ensures the authenticity of the app, prevents tampering, and is required for distributing the app (via the Google Play Store or any other distribution method).

• Keystore: A keystore file contains the private keys used for signing the app. You can create a keystore manually or let Android Studio create one for you.

• Signing Configurations: These are the settings that specify which keystore and key alias to use for signing your APK or AAB.

Steps to Handle Signing in Android Studio:

1. Create a Keystore: If you don’t already have a keystore, you need to create one. You can do this using the keytool utility, which is included with the JDK. Run the following command in your terminal:

   keytool -genkeypair -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -dname "CN=MyApp, OU=MyOrganization, O=MyCompany, L=MyCity, ST=MyState, C=MyCountry"

   This will create a .jks (Java Keystore) file which will be used to sign the APK.

2. Configure Signing in build.gradle: In the module-level build.gradle, configure the signing information. Add a signingConfigs block to specify the keystore file, alias, and passwords.

   Example:

   android {
       signingConfigs {
           release {
               storeFile file("path/to/your/keystore/my-release-key.jks")  // Path to your keystore file
               storePassword "your-keystore-password"                      // Keystore password
               keyAlias "my-key-alias"                                     // Key alias
               keyPassword "your-key-password"                             // Key password
           }
       }
   
       buildTypes {
           release {
               signingConfig signingConfigs.release  // Apply signing config to the release build type
               minifyEnabled true  // Enable code shrinking for release builds
               proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
           }
       }
   }

   • storeFile: The path to the keystore file.
   • storePassword: The password to access the keystore.
   • keyAlias: The alias name for the key inside the keystore.
   • keyPassword: The password for the alias.

3. Build the Signed APK/AAB: After configuring the signing details in build.gradle, you can build a signed APK or AAB.

   • For APK: Go to Build > Build Bundle(s) / APK(s) > Build APK(s) in the Android Studio menu.
   • For AAB: Go to Build > Build Bundle(s) / APK(s) > Build Bundle for generating the Android App Bundle, which is preferred for Google Play distribution.

   Android Studio will automatically use the signing configuration and sign the APK or AAB with the provided keystore.

---

3. Handling Multiple Build Variants with Signing

In Android Studio, you can manage signing configurations for different build variants, such as debug and release builds, or free and paid flavors.

For example, you can configure different signing keys for debug and release versions:

android {
    signingConfigs {
        debug {
            storeFile file("path/to/debug.keystore")
            storePassword "debug-store-password"
            keyAlias "debug-key-alias"
            keyPassword "debug-key-password"
        }
        release {
            storeFile file("path/to/release.keystore")
            storePassword "release-store-password"
            keyAlias "release-key-alias"
            keyPassword "release-key-password"
        }
    }

    buildTypes {
        debug {
            signingConfig signingConfigs.debug
        }
        release {
            signingConfig signingConfigs.release
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

In this case:

• Debug builds use a different keystore and password for signing, which is typically provided by Android Studio automatically.
• Release builds use the release keystore for signing and enable code shrinking (e.g., ProGuard or R8).

4. Publishing Signed APK/AAB

After signing the app, you can publish it on platforms like Google Play Store.

• APK: When you’re publishing to Google Play or distributing via other methods, you can upload the signed APK directly. However, Google Play now prefers Android App Bundles (AAB) for more efficient app delivery.
• AAB: After building the signed AAB, go to the Google Play Console, create a new release, and upload the AAB. Google Play will generate optimized APKs for each device configuration.

---

5. Managing Versioning and Signing for Release:

• Ensure that the versionCode is incremented with every new release. The versionCode must always be greater than the last uploaded version on the app store (Google Play).
• Use ProGuard or R8 for release builds to minimize and optimize the APK, obfuscating the code and stripping unused resources.
• Always store your keystore file in a secure location and back it up. If you lose the keystore, you will not be able to update your app on the app store.

---

Summary:

• Versioning: Manage the versionCode and versionName in the defaultConfig block of the build.gradle file to differentiate between app versions.
• Signing: Configure signing configurations for each build type (debug, release) in build.gradle. Use a keystore to securely sign your app before distributing it.
• Build Variants: Handle multiple build variants (e.g., debug/release or product flavors) with different signing configurations in the build.gradle file.
• Publishing: After signing, you can publish the APK or AAB to Google Play or other distribution platforms.

Proper handling of versioning and signing ensures that your Android app remains secure, properly versioned, and ready for distribution on platforms like Google Play.

Question: What are Android Studio shortcuts that can improve your development productivity?

Answer:

Android Studio offers a wide variety of keyboard shortcuts that can help speed up development and make you more efficient while working on Android projects. Here are some essential shortcuts that every Android developer should know:

---

1. Basic Navigation Shortcuts:

• Search Everywhere: Shift twice

  • Quickly search for classes, files, symbols, or actions in your project.

• Go to File: Ctrl + Shift + N (Windows/Linux) or Cmd + Shift + O (macOS)

  • Open any file in your project by name.

• Go to Class: Ctrl + N (Windows/Linux) or Cmd + O (macOS)

  • Quickly navigate to a class by typing its name.

• Go to Symbol: Ctrl + Alt + Shift + N (Windows/Linux) or Cmd + Option + O (macOS)

  • Find a method, variable, or symbol in your project.

• Go to Definition: Ctrl + B (Windows/Linux) or Cmd + B (macOS)

  • Navigate to the declaration of a variable, method, or class.

• Go to Line: Ctrl + G (Windows/Linux) or Cmd + L (macOS)

  • Jump to a specific line number in the current file.

• Recent Files: Ctrl + E (Windows/Linux) or Cmd + E (macOS)

  • Show a list of recently opened files.

• Recent Edited Files: Ctrl + Shift + E (Windows/Linux) or Cmd + Shift + E (macOS)

  • Show a list of recently edited files.

• Navigate Back/Forward: Ctrl + Alt + Left/Right (Windows/Linux) or Cmd + Option + Left/Right (macOS)

  • Navigate back or forward through the files you’ve previously opened.

---

2. Code Editing Shortcuts:

• Autocomplete/Intellisense: Ctrl + Space (Windows/Linux) or Cmd + Space (macOS)

  • Trigger code suggestions and autocompletion.

• Generate Code: Alt + Insert (Windows/Linux) or Cmd + N (macOS)

  • Automatically generate constructors, getters/setters, and other boilerplate code.

• Reformat Code: Ctrl + Alt + L (Windows/Linux) or Cmd + Option + L (macOS)

  • Reformat the code to match the project’s coding style.

• Find and Replace: Ctrl + R (Windows/Linux) or Cmd + R (macOS)

  • Search for text within the current file and replace it.

• Find in Path: Ctrl + Shift + F (Windows/Linux) or Cmd + Shift + F (macOS)

  • Search for a string across the entire project.

• Replace in Path: Ctrl + Shift + R (Windows/Linux) or Cmd + Shift + R (macOS)

  • Search and replace across the entire project.

• Comment/Uncomment: Ctrl + / (Windows/Linux) or Cmd + / (macOS)

  • Toggle comment on a single line of code.

• Block Comment/Uncomment: Ctrl + Shift + / (Windows/Linux) or Cmd + Shift + / (macOS)

  • Block comment multiple lines of code.

• Surround with Code (e.g., if/else, try/catch): Ctrl + Alt + T (Windows/Linux) or Cmd + Option + T (macOS)

  • Wrap selected code with constructs like try/catch or if statements.

---

3. Debugging Shortcuts:

• Start Debugging: Shift + F9

  • Start a debugging session.

• Step Over: F8

  • Step over the current line of code during debugging.

• Step Into: F7

  • Step into the current method or function during debugging.

• Step Out: Shift + F8

  • Step out of the current method or function.

• Toggle Breakpoint: Ctrl + F8 (Windows/Linux) or Cmd + F8 (macOS)

  • Add or remove a breakpoint on the current line.

• Run to Cursor: Alt + F9 (Windows/Linux) or Option + F9 (macOS)

  • Run the program directly to the current line.

• Evaluate Expression: Alt + F8 (Windows/Linux) or Option + F8 (macOS)

  • Evaluate expressions while debugging.

---

4. Refactoring Shortcuts:

• Rename: Shift + F6

  • Rename a variable, class, method, or file.

• Move: F6

  • Move a file, class, or method to a different package or directory.

• Extract Method: Ctrl + Alt + M (Windows/Linux) or Cmd + Option + M (macOS)

  • Extract a selected block of code into a new method.

• Extract Variable: Ctrl + Alt + V (Windows/Linux) or Cmd + Option + V (macOS)

  • Extract a selected expression into a new variable.

• Extract Constant: Ctrl + Alt + C (Windows/Linux) or Cmd + Option + C (macOS)

  • Extract a selected expression into a constant.

• Change Signature: Ctrl + F6 (Windows/Linux) or Cmd + F6 (macOS)

  • Change the signature of a method (parameters, return type, etc.).

---

5. Build and Run Shortcuts:

• Build Project: Ctrl + F9 (Windows/Linux) or Cmd + F9 (macOS)

  • Build the entire project.

• Make Project: Ctrl + F10 (Windows/Linux) or Cmd + F10 (macOS)

  • Compile the project (not full build).

• Run Project: Shift + F10 (Windows/Linux) or Cmd + Shift + R (macOS)

  • Run the project.

• Rebuild Project: Ctrl + Shift + F9 (Windows/Linux) or Cmd + Shift + F9 (macOS)

  • Clean and rebuild the project from scratch.

---

6. Project and Version Control Shortcuts:

• View Project Tool Window: Alt + 1 (Windows/Linux) or Cmd + 1 (macOS)

  • Open the Project panel to navigate your project’s files.

• Show Version Control: Alt + 9 (Windows/Linux) or Cmd + 9 (macOS)

  • Open the version control tool window to manage Git, SVN, etc.

• Commit Changes: Ctrl + K (Windows/Linux) or Cmd + K (macOS)

  • Commit changes to the version control system.

• Update Project from Version Control: Ctrl + T (Windows/Linux) or Cmd + T (macOS)

  • Pull the latest changes from the version control repository.

• Show Git Log: Ctrl + Alt + Shift + L (Windows/Linux) or Cmd + Option + Shift + L (macOS)

  • Open the log to view commit history.

---

7. UI/Design Shortcuts:

• Switch between XML and Design View: Alt + 1 (XML) / Alt + 2 (Design) (Windows/Linux) or Cmd + 1 (XML) / Cmd + 2 (Design) (macOS)

  • Toggle between XML and Design tabs in the layout editor.

• Zoom in/out (Editor): Ctrl + Mouse Wheel (Windows/Linux) or Cmd + Mouse Wheel (macOS)

  • Zoom in or out in the code editor.

• Show Layout Preview: Ctrl + Shift + P (Windows/Linux) or Cmd + Shift + P (macOS)

  • Preview the layout in real-time.

---

8. Miscellaneous Shortcuts:

• Show Documentation: Ctrl + Q (Windows/Linux) or Cmd + J (macOS)

  • Show documentation for a method or class.

• Show Parameter Info: Ctrl + P (Windows/Linux) or Cmd + P (macOS)

  • Display parameter info when calling a function or method.

• Surround Code with Template (if/else, try/catch): Ctrl + Alt + T (Windows/Linux) or Cmd + Option + T (macOS)

  • Surround selected code with control structures.

• Find Action: Ctrl + Shift + A (Windows/Linux) or Cmd + Shift + A (macOS)

  • Search for any action or command in Android Studio (e.g., settings, tools).

---

Conclusion:

These Android Studio shortcuts can significantly improve your development speed and workflow. By reducing the need for constant mouse interactions, you can focus more on coding and testing. For best results, practice these shortcuts regularly, as muscle memory will help you use them effectively over time.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as android-studio interview questions, android-studio interview experiences, and details about various android-studio job positions. Click here to check it out.