I want to setup the Android dev environment from command line, and encounter the following issue:
wget http://dl.google.com/android/android-sdk_r22.0.5-linux.tgz
after extract the file, run
tools/android update sdk --no-ui
However, it is too slow on running
Fetching https://dl-ssl.google.com/android/repository/addons_list-2.xml
The result is that nothing in folder build-tools, and I want is aapt and apkbuilder, since I want to build apk from command line without ant.
By default, the SDK Manager from the command line does not include the build tools in the list. They're in the "obsolete" category. To see all available downloads, use
android list sdk --all
And then to get one of the packages in that list from the command line, use:
android update sdk -u -a -t <package no.>
Where -u stands for --no-ui, -a stands for --all and -t stands for --filter.
If you need to install multiple packages do:
android update sdk -u -a -t 1,2,3,4,..,n
Where 1,2,..,n is the package number listed with the list command above
As mentioned in other answers, you can use the --filter option to limit the installed packages:
android update sdk --filter ...
The other answers don't mention that you can use constant string identifiers instead of indexes (which will change) for the filter options. This is helpful for unattended or scripted installs. Man for --filter option:
... This also accepts the identifiers returned by 'list sdk --extended'.
android list sdk --all --extended :
Packages available for installation or update: 97
----------
id: 1 or "tools"
Type: Tool
Desc: Android SDK Tools, revision 22.6.2
----------
id: 2 or "platform-tools"
Type: PlatformTool
Desc: Android SDK Platform-tools, revision 19.0.1
----------
id: 3 or "build-tools-19.0.3"
Type: BuildTool
Desc: Android SDK Build-tools, revision 19.0.3
Then you can use the string ids as the filter options to precisely specify the versions you want:
android update sdk --filter tools,platform-tools,build-tools-19.0.3 etc
Version 25.2.3 (and higher) of Android SDK Tools package contains new tool - sdkmanager - which simplifies this task of installing build-tools from the command line.
It is located in android_sdk/tools/bin folder.
Usage (from documentation):
List installed and available packages:
sdkmanager --list [options] \
[--channel=channel_id] // Channels: 0 (stable), 1 (beta), 2 (dev), or 3 (canary)
Use the channel option to include a package from a channel up to and including channel_id. For example, specify the canary channel to list packages from all channels.
Install packages:
sdkmanager packages [options]
The packages argument is an SDK-style path, wrapped in quotes (for
example, "build-tools;25.0.0" or "platforms;android-25"). You can
pass multiple package paths, separated with a space, but they must
each be wrapped in their own set of quotes.
Example usage (on my Mac):
alex#mbpro:~/sdk/tools/bin$ ls ../../build-tools/
25.0.0/
alex#mbpro:~/sdk/tools/bin$ ./sdkmanager "build-tools;25.0.2"
done
alex#mbpro:~/sdk/tools/bin$ ls ../../build-tools/
25.0.0/ 25.0.2/
You can also specify various options, for example to force all connections to use HTTP (--no_https), or in order to use proxy server (--proxy_host=address and --proxy_port=port).
To check the available options, use the --help flag. On my machine (Mac), the output is as following:
alex#mbpro:~/sdk/tools/bin$ ./sdkmanager --help
Usage:
sdkmanager [--uninstall] [<common args>] \
[--package_file <package-file>] [<packages>...]
sdkmanager --update [<common args>]
sdkmanager --list [<common args>]
In its first form, installs, or uninstalls, or updates packages.
<package> is a sdk-style path (e.g. "build-tools;23.0.0" or
"platforms;android-23").
<package-file> is a text file where each line is a sdk-style path
of a package to install or uninstall.
Multiple --package_file arguments may be specified in combination
with explicit paths.
In its second form (with --update), currently installed packages are
updated to the latest version.
In its third form, all installed and available packages are printed out.
Common Arguments:
--sdk_root=<sdkRootPath>: Use the specified SDK root instead of the SDK containing this tool
--channel=<channelId>: Include packages in channels up to <channelId>.
Common channels are:
0 (Stable), 1 (Beta), 2 (Dev), and 3 (Canary).
--include_obsolete: With --list, show obsolete packages in the
package listing. With --update, update obsolete
packages as well as non-obsolete.
--no_https: Force all connections to use http rather than https.
--proxy=<http | socks>: Connect via a proxy of the given type.
--proxy_host=<IP or DNS address>: IP or DNS address of the proxy to use.
--proxy_port=<port #>: Proxy port to connect to.
* If the env var REPO_OS_OVERRIDE is set to "windows",
"macosx", or "linux", packages will be downloaded for that OS.
ADB Build-Tools Will Not be downloaded automatically, by command android update sdk --no-ui
So for installing Buil-Tool type (in console):
android list sdk --all
Remember the number that is listed before the item and execute the following:
android update sdk -u --all --filter <number>
commands should be typed in /YourFolder/android-sdk-linux/tools
Also for remote folder (server opened by ssh for example) type:
**./android** list sdk --all
**./android** update sdk -u --all --filter <number>
For simple list of ADB packages type in terminal:
android list sdk
for install all packages:
android update sdk --no-ui
Or with filters (comma is separator):
android update sdk --no-ui --filter 3,5,8,14
A great source of information I came across while trying to install everything Android SDK related from the command line, was this Dockerfile. Inside the Dockerfile you can see that the author executes a single command to install platform tools and build tools without any other interaction. In the case the OP has put forth, the command would be adapted to:
echo y | $ANDROID_HOME/tools/android update sdk --all --filter build-tools-21.1.0 --no-ui
If you have sdkmanager installed (I'm using MAC)
run sdkmanager --list to list available packages.
If you want to install build tools, copy the preferred version from the list of packages available.
To install the preferred version run
sdkmanager "build-tools;27.0.3"
The "android" command is deprecated.
For command-line tools, use tools/bin/sdkmanager and tools/bin/avdmanager
If you do not need Android Studio, you can download the basic Android command line tools from developer.android.com in section Command line tools only.
from CLI it should be somfing like:
curl --output sdk-tools-linux.zip https://dl.google.com/android/repository/sdk-tools-linux-4333796.zip
or
wget --output-document sdk-tools-linux.zip https://dl.google.com/android/repository/sdk-tools-linux-4333796.zip
After that just unpack the archive to the target folder
unzip sdk-tools-linux.zip
And now we can install everything you need...
./tools/bin/sdkmanager --install 'build-tools;29.0.2' 'platform-tools' 'platforms;android-29' 'tools'
You can get a complete list of packages using the command ./tools/bin/sdkmanager --list
Some packages require acceptance of the license agreement. you can accept it interactively or just pass "y" to the input stream, like this(two agreements in case):
echo -ne "y\ny" | ./tools/bin/sdkmanager --install 'system-images;android-29;default;x86_64'
And of course, for your convenience, you can export variables such as ANDROID_HOME or ANDROID_SDK_ROOT (including doing it in ~/.profile or ~/.bash_profile) or patch the PATH variable - all this is at your discretion.
Script example:
mkdir /opt/android-sdk
cd /opt/android-sdk
curl --output sdk-tools-linux.zip https://dl.google.com/android/repository/sdk-tools-linux-4333796.zip
unzip sdk-tools-linux.zip
echo -ne "y" | ./tools/bin/sdkmanager --install 'build-tools;29.0.2' 'platform-tools' 'platforms;android-29' 'tools'
Requirements:
curl(or wget) and unzip
Troubleshooting:
if you see Warning: Could not create settings, you need to have the tools directory inside the cmdline-tools directory inside the ANDROID_HOME (create it if needed with this exact name) see Android Command line tools sdkmanager always shows: Warning: Could not create settings
I just had a heck of a time getting android sdk dependencies installed via command line and since the documentation that comes with the tools and online are woefully lacking, I thought I'd post what I discovered here.
I'm working with android sdk r24.4.1 for linux. There are two commands that you can run to list the available packages:
android list sdk
and the more exhaustive:
android list sdk --all
The package numbers for specific packages differ for each command above! For example, the former lists package API 23.1 revision 3 as package #3 and the latter lists it as #29.
Now, there are two different ways to install using the android command.
tools/android update sdk --no-ui --filter <package number>
and
tools/android update sdk -u -a -t <package number>
Given that the install commands each can take the package # as a parameter, which package number do you use? After much online searching and trial and error, I discovered that
android update sdk --no-ui --filter uses the package numbers from android list sdk
and
android update sdk -u -a -t uses the package numbers from android list sdk --all
In other words - to install API 23.1 revision 3 you can do either:
android update sdk --no-ui --filter 3
or
android update sdk -u -a -t 29
Crazy, but it works.
Most of the answers seem to ignore the fact that you may need to run the update in a headless environment with no super user rights, which means the script has to answer all the y/n license prompts automatically.
Here's the example that does the trick.
FILTER=tool,platform,android-20,build-tools-20.0.0,android-19,android-19.0.1
( sleep 5 && while [ 1 ]; do sleep 1; echo y; done ) \
| android update sdk --no-ui --all \
--filter ${FILTER}
No matter how many prompts you get, all of those will be answered. This while/sleep loop looks like simulation of the yes command, and in fact it is, well almost. The problem with yes is that it floods stdout with 'y' and there is virtually no delay between sending those characters and the version I had to deal with had no timeout option of any kind. It will "pollute" stdout and the script will fail complaining about incorrect input. The solution is to put a delay between sending 'y' to stdout, and that's exactly what while/sleep combo does.
expect is not available by default on some linux distros and I had no way to install it as part of my CI scripts, so had to use the most generic solution and nothing can be more generic than simple bash script, right?
As a matter of fact, I blogged about it (NSBogan), check it out for more details here if you are interested.
However, it is too slow on running
Yes, I've had the same problem. Some of the file downloads are extremely slow (or at least they have been in the last couple of days). If you want to download everything there's not a lot you can do about that.
The result is that nothing in folder build-tools, and I want is aapt and apkbuilder, since I want to build apk from command line without ant.
Did you let it run to completion?
One thing you can do is filter the packages that are being downloaded using the -t switch.
For example:
tools/android update sdk --no-ui -t platform-tool
When I tried this the other day I got version 18.0.0 of the build tools installed. For some reason the latest version 18.0.1 is not included by this filter and the only way to get it was to install everything with the --all switch.
I prefer to put a script that install my dependencies
Something like:
#!/usr/bin/env bash
#
# Install JUST the required dependencies for the project.
# May be used for ci or other team members.
#
for I in android-25 \
build-tools-25.0.2 \
tool \
extra-android-m2repository \
extra-android-support \
extra-google-google_play_services \
extra-google-m2repository;
do echo y | android update sdk --no-ui --all --filter $I ; done
https://github.com/caipivara/android-scripts/blob/master/install-android-dependencies.sh
I just had this problem, so I finally wrote a 1 line bash dirty solution by reading and parsing the list of aviable tools :
tools/android update sdk -u -t $(android list sdk | grep 'Android SDK Build-tools' | sed 's/ *\([0-9]\+\)\-.*/\1/')
Inspired from answers by #i4niac & #Aurélien Lambert, this is what i came up with
csv_update_numbers=$(./android list sdk --all | grep 'Android SDK Build-tools' | grep -v 'Obsolete' | sed 's/\(.*\)\- A.*/\1/'|sed '/^$/d'|sed -e 's/^[ \t]*//'| tr '\n' ',')
csv_update_numbers_without_trailing_comma=${csv_update_numbers%?}
( sleep 5 && while [ 1 ]; do sleep 1; echo y; done ) \
| ./android update sdk --all -u -t $csv_update_numbers_without_trailing_comma
Explanation
get a comma separated list of numbers which are the indexes of build tools packages in the result of android list sdk --all command (Ignoring obsolete packages).
keep throwing 'y's at the terminal every few miliseconds to accept the licenses.
Download android SDK from developer.android.com (its currently a 149mb file for windows OS). It is worthy of note that android has removed the sdkmanager GUI but has a command line version of the sdkmanager in the bin folder which is located inside the tools folder.
When inside the bin folder, hold down the shift key, right click, then select open command line here.
Shift+right click >> open command line here.
When the command line opens, type sdkmanager click enter.
Then run type sdkmanager (space), double hyphen (--), type list
sdkmanager --list (this lists all the packages in the SDK manager)
Type sdkmanager (space) then package name, press enter.
Eg. sdkmanager platform-tools (press enter)
It will load licence agreement. With options (y/n). Enter y to accept and it will download the package you specified.
For more reference follow official document here
I hope this helps. :)
Build tools could not be downloaded automatically by default as Nate said in https://stackoverflow.com/a/19416222/1104031 post.
But I wrote small tool that make everything for you
I used "expect" tool as danb in https://stackoverflow.com/a/17863931/1104031 post.
You only need android-sdk and python27, expect.
This script will install all build tools, all sdks and everything you need for automated build:
import subprocess,re,sys
w = subprocess.check_output(["android", "list", "sdk", "--all"])
lines = w.split("\n")
tools = filter(lambda x: "Build-tools" in x, lines)
filters = []
for tool in tools:
m = re.search("^\s+([0-9]+)-", tool)
tool_no = m.group(1)
filters.append(tool_no)
if len(filters) == 0:
raise Exception("Not found build tools")
filters.extend(['extra', 'platform', 'platform-tool', 'tool'])
filter = ",".join(filters)
expect= '''set timeout -1;
spawn android update sdk --no-ui --all --filter %s;
expect {
"Do you accept the license" { exp_send "y\\r" ; exp_continue }
eof
}''' % (filter)
print expect
ret = subprocess.call(["expect", "-c", expect])
sys.exit(ret)
As stated in other responses, the build tools requires the --all flag to be installed. You also better use a -t filter flag to avoid installing ALL the packages but there is no way to filter all the build tools.
There are already features requests for these two points in AOSP bug tracker. Feel free to vote for them, this might make them happen some day:
https://code.google.com/p/android/issues/detail?id=78765
https://code.google.com/p/android/issues/detail?id=58337
I tried this for update all, and it worked!
echo y | $ANDROID_HOME/tools/android update sdk --no-ui
Try
1. List all packages
android list sdk --all
2. Install packages using following command
android update sdk -u -a -t package1, package2, package3 //comma seperated packages obtained using list command
android update sdk
This command will update and install all latest release for SDK Tools, Build Tools,SDK platform tools.
It's Work for me.
To setup android environment without installating the whole android studio :
Download JDK (version greater than 8)
Download gradle from https://gradle.org/install/
Download command line tools from https://developer.android.com/studio scroll down and download command line tools only
Setup the necessary environment variables
Download the necessary SDK tools
Related
I use the new command line tools for Android because the old sdk-tools repository of Android isn't available anymore. So I changed my gitlab-ci to load the commandlintools. But when I try to run it I get the following error:
Warning: Could not create settings
java.lang.IllegalArgumentException
at com.android.sdklib.tool.sdkmanager.SdkManagerCliSettings.<init>(SdkManagerCliSettings.java:428)
at com.android.sdklib.tool.sdkmanager.SdkManagerCliSettings.createSettings(SdkManagerCliSettings.java:152)
at com.android.sdklib.tool.sdkmanager.SdkManagerCliSettings.createSettings(SdkManagerCliSettings.java:134)
at com.android.sdklib.tool.sdkmanager.SdkManagerCli.main(SdkManagerCli.java:57)
at com.android.sdklib.tool.sdkmanager.SdkManagerCli.main(SdkManagerCli.java:48)
I already tried executing those commandy by hand, but I get the same error. Also if I run sdkmanager --version, the same error occurs.
My gitlab-ci looks like:
image: openjdk:9-jdk
variables:
ANDROID_COMPILE_SDK: "29"
ANDROID_BUILD_TOOLS: "29.0.3"
ANDROID_SDK_TOOLS: "6200805"
before_script:
- apt-get --quiet update --yes
- apt-get --quiet install --yes wget tar unzip lib32stdc++6 lib32z1
- wget --quiet --output-document=android-sdk.zip https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_SDK_TOOLS}_latest.zip
- unzip -d android-sdk-linux android-sdk.zip
- echo y | android-sdk-linux/tools/bin/sdkmanager "platform-tools" "platforms;android-${ANDROID_COMPILE_SDK}" >/dev/null
#- echo y | android-sdk-linux/tools/bin/sdkmanager "platform-tools" >/dev/null
- echo y | android-sdk-linux/tools/bin/sdkmanager "build-tools;${ANDROID_BUILD_TOOLS}" >/dev/null
- export ANDROID_HOME=$PWD/android-sdk-linux
- export PATH=$PATH:$PWD/android-sdk-linux/platform-tools/
- chmod +x ./gradlew
# temporarily disable checking for EPIPE error and use yes to accept all licenses
- set +o pipefail
- yes | android-sdk-linux/tools/bin/sdkmanager --licenses
- set -o pipefail
stages:
- build
- test
lintDebug:
stage: build
script:
- ./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint
assembleDebug:
stage: build
script:
- ./gradlew assembleDebug
artifacts:
paths:
- app/build/outputs/
debugTests:
stage: test
script:
- ./gradlew -Pci --console=plain :app:testDebug
Instead of passing the argument --sdk_root for each single command execution, let's deep dive into the real cause.
Starting from Android SDK Command-line Tools 1.0.0 (6200805), in contrast to Android SDK 26.1.1 (4333796), the tools directory hierarchy has been changed.
Previously it was placed right inside ANDROID_HOME (which is deprecated, we will use the term ANDROID_SDK_ROOT for the rest of the paragraph), now it's still named as tools (the only thing you'll get after unpacking the downloaded commandlinetools zip file), but differently, you have to place it inside a directory called cmdline-tools on your own. The name cmdline-tools comes from its package name, where you can get from listing packages command sdkmanager --list, whose outputs include cmdline-tools;1.0 | 1.0 | Android SDK Command-line Tools.
Wrapping tools directory inside cmdline-tools directory would make it work, and help you get rid of the annoying --sdk_root argument. But what about the other parts?
Well, that's all you have to change. Let me explain more.
The king - sdkmanager lives inside cmdline-tools/tools/bin, you'd better set in PATH environment variable
cmdline-tools should not be set as ANDROID_SDK_ROOT. Because later, when updating Android SDK, or installing more packages, the other packages will be placed under ANDROID_SDK_ROOT, but not under cmdline-tools.
The final, complete ANDROID_SDK_ROOT directory structure should look like below, consist of quite a few sub-directories: build-tools, cmdline-tools, emulator, licenses, patcher, platform-tools, platforms, system-images. You can easily point out that build-tools and cmdline-tools are siblings, all sit inside the parent ANDROID_SDK_ROOT.
Let me recap in a simple way:
Set your preferred ANDROID_SDK_ROOT (just like before)
Download and unpack the commandlinetools zip file into a directory called cmdline-tools, which is inside ANDROID_SDK_ROOT
Append the directory $ANDROID_SDK_ROOT/cmdline-tools/tools/bin to environment variable PATH, so that the system knows where to find sdkmanager
!!UPDATE!!
The behavior has changed again since the build 6858069 (Android SDK Command-line Tools 3.0):
After unzipping the package, the top-most directory you'll get is cmdline-tools.
Rename the unpacked directory from cmdline-tools to tools, and place it under $ANDROID_SDK_ROOT/cmdline-tools, so now it should look like: $ANDROID_SDK_ROOT/cmdline-tools/tools. And inside it, you should have: NOTICE.txt bin lib source.properties. Actually according to the official Command-Line Tools doc, the tree structure should be android_sdk/cmdline-tools/version/bin/, but I've checked, using version or tools makes no difference here.
For your environment variable PATH, I would recommend you to set like this: PATH=$PATH:$ANDROID_SDK_ROOT/cmdline-tools/latest/bin:$ANDROID_SDK_ROOT/cmdline-tools/tools/bin, because after update later, you'll get the latest sdkmanager placed under $ANDROID_SDK_ROOT/cmdline-tools/latest/bin, put it in front will make it higher priority.
This appears to be a bug with the way sdkmanager locates the SDK installation folder.
A work-around is to set the flag --sdk_root. You can move ANDROID_HOME declaration higher, then use it with the subsequent commands.
- export ANDROID_HOME=$PWD/android-sdk-linux
- yes | android-sdk-linux/tools/bin/sdkmanager --sdk_root=${ANDROID_HOME} --licenses
- android-sdk-linux/tools/bin/sdkmanager --sdk_root=${ANDROID_HOME} "platform-tools" "platforms;android-${ANDROID_COMPILE_SDK}" >/dev/null
Also, moved blanket license acceptance command to the first command to clean up the echo y parts.
Oddly enough if you run sdkmanager --sdk_root=${ANDROID_HOME} "tools" it will upgrade tools from 3.6.0 to 26.1.1 and sdkmanager no longer has this issue. This update takes time and bandwidth and isn't exactly necessary with the work-around.
For those who struggled with installing Android Command Line Tools for Appium on Windows 10/x64 just do as following:
Download latest Command line tools from android i.e. commandlinetools-win-6200805_latest.zip
Unzip the downloaded file
Create directory for storing commandline tools somewhere on your disk, with following path included: android/cmdline-tools/latest Basically when You unzip this Cmd line tools, just rename tools directory to latest and make sure You put this latest folder in android/cmdline-tools directory somewhere on your disk
Create ANDROID_HOME environment variable for directory that stores the cmdline tools directory location like:
C:\YourLocationWhereYouStoreTheDirectory\android\cmdline-tools\latest
Create new entry in Path environment variable as %ANDROID_HOME%\bin
The sdkmanager tries to figure out the android-sdk path based in where it's unpacked, without use the environment variables, like ANDROID_SDK_ROOT. But it's get worse, because it have a hard coded parent folder named cmdline-tools and if you unzip commandlinetools inside a folder with another name, it doesn't work, forcing us to use the parameter sdk_root to feed the inside variable correctly.
So, with that in mind we can use the following approach to solve this.
I will assume that we are using Ubuntu OS, so if you aren't, you should adapt some of that instructions.
Install Android-SDK.
sudo apt install android-sdk
After the instalation you will have a folder called android-sdk in /usr/lib
Create a folder called cdmline-tools inside the android-sdk folder
sudo mkdir /usr/lib/android-sdk/cmdline-tools
Download the Android command line tools zip from here (https://developer.android.com/studio?hl=en-419#downloads)
Unpack the file you just downloaded inside /usr/lib/android-sdk/cmdline-tools
sudo unzip /path/for/commandlinetools-linux-6200805_latest.zip -d /usr/lib/android-sdk/cmdline-tools
Go to you home dir and edit your .profile
nano .profile
Create an ANDROID_SDK_ROOT variable
export ANDROID_SDK_ROOT=/usr/lib/android-sdk
Put the sdkmanager folder in your path
export PATH=$ANDROID_SDK_ROOT/cmdline-tools/tools/bin:$PATH
Save and Exit
Reload you profile
. ~/.profile
Run
sdkmanager --version
You should see the version printed in your terminal.
Downloading the new cmdline-tools from Android Developer website requires the following directory structure to be respected.
Simple Solution:
Open Android Studio Tools Menu,
SDK Manager In the window that comes
up there are inner panels,
Choose SDK Tools panel Tick Android SDK Command-line Tools
Choose Apply button near the bottom of the window
Mixing responses from Jing Li and caller9, this is my script:
variables:
ANDROID_COMPILE_SDK: "29"
ANDROID_BUILD_TOOLS: "29.0.3"
ANDROID_SDK_TOOLS: "6200805"
before_script:
- apt-get update --yes
- apt-get install --yes wget tar unzip lib32stdc++6 lib32z1
- export ANDROID_HOME=${PWD}android-home
- install -d $ANDROID_HOME
- wget --output-document=$ANDROID_HOME/cmdline-tools.zip https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_SDK_TOOLS}_latest.zip
- pushd $ANDROID_HOME
- unzip -d cmdline-tools cmdline-tools.zip
- popd
- export PATH=$PATH:${ANDROID_HOME}/cmdline-tools/tools/bin/
- sdkmanager --version
- set +o pipefail
- yes | sdkmanager --sdk_root=${ANDROID_HOME} --licenses
- set -o pipefail
- sdkmanager --sdk_root=${ANDROID_HOME} "platforms;android-${ANDROID_COMPILE_SDK}"
- sdkmanager --sdk_root=${ANDROID_HOME} "platform-tools"
- sdkmanager --sdk_root=${ANDROID_HOME} "build-tools;${ANDROID_BUILD_TOOLS}"
- export PATH=$PATH:${ANDROID_HOME}/platform-tools/
- chmod +x ./gradlew
[...]
I found the solution to use the latest command-line tools following those steps:
1 - Extracting the Command-line tools into a folder with this structure:
e.g.: $HOME/Development/android/cmdline-tools/latest
(this folder must contain lib, bin, notice.txt and source.properties)
2 - Defining ANDROID_HOME as an environment variable:
ANDROID_HOME="$HOME/Development/android/cmdline-tools/latest"
3 - Loading it on PATH:
PATH="$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/tools/lib:$ANDROID_HOME/tools/bin:$ANDROID_HOME/platform-tools"
Got the same issue, came here by Google.
According to the AndroidStudio Archive, today was the release of 4.1.
I suppose that's no coincidence.
This completely unrelated guide has a hardlink for an older version of the sdk-tools for linux.
You can change the url to windows or mac for other OSs. I'll use that as a hotfix for now.
(that was supposed to be a comment not a solution)
Summarizing several useful posts here, and for people wanting a quick snippet, for example to plug in a Dockerfile, the following script is working for me:
RUN mkdir -p /opt/android/cmdline-tools/latest \
&& cd /opt/android/cmdline-tools/latest \
&& wget https://dl.google.com/android/repository/commandlinetools-linux-6858069_latest.zip \
&& bsdtar --strip-components=1 -xvf commandlinetools-linux-6858069_latest.zip \
&& yes | bin/sdkmanager --licenses \
&& bin/sdkmanager "build-tools;29.0.2" "platforms;android-29" \
&& rm commandlinetools-linux-6858069_latest.zip
It just requires bsdtar to be installed (it's usually packaged in popular distributions). Android platform/build tools version 29 are installed, and Android sdk root will be then located in /opt/android. While this setup works for me without warnings as it is, I have an issue when reinstalling packages already installed, or possibly installing different version of the packages: it clashes with packages already present and create bogus directories in the sdk root, with -2, -3 suffixes. These directories are then ignored, and warnings like Observed package id 'emulator' in inconsistent location are printed, so this behavior is definitely not desirable. If you have a fix for that please write it in the comments or, if you are confident enough, just edit the script with the exact fix.
Just solved this issue with IDE, looks pretty simple to me. (Actually this duplicate previous answer but with the picture). Just install sdk tools and everything should work.
I got the same error. After doing all solutions, i could not fix it. I solved this problem by reading: https://forum.unity.com/threads/android-build-not-working.844969/
Simplify an answer:
Opening sdkmanager.bat by notepad++
Changing this line from
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %SDKMANAGER_OPTS% -classpath "%CLASSPATH%" com.android.sdklib.tool.sdkmanager.SdkManagerCli %CMD_LINE_ARGS%
to
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %SDKMANAGER_OPTS% -classpath "%CLASSPATH%" com.android.sdklib.tool.sdkmanager.SdkManagerCli %CMD_LINE_ARGS% --sdk_root=%ANDROID_HOME%
(Note: Adding --sdk_root=%ANDROID_HOME% at the end
I would like to share my experience.
At first I try to explain why directory structure has to look
the way shown in this answer - https://stackoverflow.com/a/60460681/1758733 .
https://stackoverflow.com/users/668455/tristan asked for explanation several times so hope I will clarify
the situtation with the next experiment:
1. unpack cmdline-tools to any path, for example c:\Android\tools;
2. create a folder for SDK, let it be c:\Android\SDK;
3. install cmdline-tools (yes, we install cmdline-tools again =)):
c:\Android\tools\bin\sdkmanager --sdk_root=c:\Android\SDK "cmdline-tools;latest"
4. at this moment we can examine c:\Android\SDK and locate
the path c:\Android\SDK\cmdline-tools\latest. If we compare
this folder with the previous version c:\Android\tools we find out
that they are identical. The new installed c:\Android\SDK\cmdline-tools\latest\sdkmanager works
without --sdk_root argument so we could initially unpack cmdline-tools
to cmdline-tools\latest.
One may encounter another issue - Stuck at ".android/repositories.cfg could not be loaded."
Other issues & facts:
1. QtCreator works with another sdkmanager that placed in SDK_ROOT/tools/bin
2. SDK_ROOT/tools/bin/sdkmanager works only with JDK 8
3. Java uses its own storage for certificates and it's not convinient usually.
Thus one may want to use Windows certificate store. Unfortunately Grandle has the
issue - https://stackoverflow.com/a/59056537 - so use the following:
set JAVA_OPTS=-Djavax.net.ssl.trustStoreType=Windows-ROOT -Djavax.net.ssl.trustStore=NUL
To sum up the following recipe for development with Qt can be composed:
1. download commandlinetools-win-6200805_latest.zip
2. extract cmdline-tools so there will be hierarchy
SDKROOT
- cmdline-tools
- latest
- bin
- sdkmanager.bat
- ...
- lib
- ...
3. install JDK 8. set JAVA_HOME=c:\path\to\java so that %JAVA_HOME%/bin/java.exe exists.
4. set JAVA_OPTS=-Djavax.net.ssl.trustStoreType=Windows-ROOT -Djavax.net.ssl.trustStore=NUL
5. NDK may be downloaded manually or installed with sdkmanager
6. install required components:
SDKROOT\cmdline-tools\latest\bin\sdkmanager "tools" "build-tools;BUILD_TOOLS_VERSION" "platform-tools" "platforms;ANDROID_VERSION"
7. run qtcreator from console so JAVA_OPTS is taken into account (or set it globaly for windows user or even station)
8. tools -> options -> devices set paths to JDK 8, SDKROOT and NDK
This happened to me when downloading the standalone command line tools (commandlinetools-mac-6200805_latest) on a new Mac.
Based on all the answers here, I was able to make it work like this
# Define ANDROID_HOME, if not defined already
export ANDROID_HOME="~/Library/Android/sdk"
# Create the folder if missing
mkdir -p $ANDROID_HOME
# Let the tool know that it should use that SDK location.
sdkmanager --list --sdk_root=$ANDROID_HOME
The docs for the --sdk_root option say "Use the specified SDK root instead of the SDK containing this tool". This made me think that, despite being shipped standalone, the tool expects to be part of a bundle where the SDK is installed aswell.
Android SDK Tools now rest in following location: "android_sdk/cmdline-tools/version/bin/";
Therefore to solve this problem in Windows (same can be replicated in other OS), do the following:
Inside your android_sdk folder, create the folder: cmdline-tools and inside it create another folder: version extract / put all your files "/bin /lib NOTICE and sources.properties" files inside this version folder.
Set ANDROID_HOME to your android_sdk folder.
Add to your System Path: android_sdk\cmdlineAndroidSDK\cmdline-tools\version\bin\
Similarly, place your Android SDK Platform Tools inside your android_sdk/platform-tools/ and add corresponding PATH to ENVIRONMENTAL VARIABLES under System Variables
Based on updated suggestions from #Jing Li. Here's my version of gitlab-ci.yml
image: openjdk:8-jdk
variables:
ANDROID_COMPILE_SDK: "30"
ANDROID_BUILD_TOOLS: "29.0.2"
ANDROID_COMMAND_LINE_TOOLS: "6858069"
GRADLE_OPTS: "-Dorg.gradle.daemon=false"
before_script:
- export GRADLE_USER_HOME=$(pwd)/.gradle
- chmod +x ./gradlew
- apt-get --quiet update --yes
- apt-get --quiet install --yes wget tar unzip lib32stdc++6 lib32z1
- mkdir -p android-sdk-linux/cmdline-tools
- export ANDROID_SDK_ROOT=$PWD/android-sdk-linux
- cd android-sdk-linux/cmdline-tools
- wget --quiet --output-document=android-sdk.zip https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_COMMAND_LINE_TOOLS}_latest.zip
- unzip android-sdk.zip
- rm android-sdk.zip
- mv cmdline-tools version
- echo y | version/bin/sdkmanager "platforms;android-${ANDROID_COMPILE_SDK}" >/dev/null
- echo y | version/bin/sdkmanager "platform-tools" >/dev/null
- echo y | version/bin/sdkmanager "build-tools;${ANDROID_BUILD_TOOLS}" >/dev/null
- export PATH=$PATH:$ANDROID_SDK_ROOT/platform-tools/
# temporarily disable checking for EPIPE error and use yes to accept all licenses
- set +o pipefail
- yes | version/bin/sdkmanager --licenses
- set -o pipefail
- cd ../../
- chmod +x ./gradlew
cache:
key: ${CI_PROJECT_ID}
paths:
- .gradle/
This page from Unity 2018 documentation also has a good explanation of resolving this issue, including such points like:
Installing the Android SDK without Android Studio.
Workaround for “Warning: Could not create settings” and “java.lang.IllegalArgumentException”
The trick for Android Studio version 3.6 or newer.
Warning about Java 9 or later, a JDK must be version 8.
https://docs.unity3d.com/2018.4/Documentation/Manual/android-sdksetup.html
Since new updates, there are some changes that are not mentioned in the documentation. After unzipping the command line tools package, the top-most directory you'll get is cmdline-tools. Rename the unpacked directory from cmdline-tools to tools, and place it under $C:/Android/cmdline-tools
now it will look like $C:/Android/cmdline-tools/tools
and it will work perfectly.
The first requirement of installing SDK (Any method) is to install Java & setting JAVA_HOME path.
Then, SDK command-line tools need installation path without which it throws NullPointerException.
To overcome this just pass the path where you want to install SDK with argument "--sdk_root"
Eg. sdkmanager.bat "platform-tools" "platforms;android-" --sdk_root=
If you are using Linux and at the same time, you don't want to mess your hands with complex workarounds, I recommend you to download and use the Snap version of sdkmanager.
Remember to use androidsdk instead of sdkmanager in the terminal.
Working Solution for Ubuntu using Android Studio
Here's the working procedure for Ubuntu and Debian like linux :
install Android studio as desribed in their website
https://developer.android.com/studio/install
run : flutter config --android-studio-dir <location of android studio> then flutter config --android-sdk /home/user/Android/Sdk (this is the default location of the SDK)
add the bin to your PATH PATH=$PATH:/home/user/Android/Sdk/tools/bin/
Afterwards, run : flutter doctor --android-licenses and accept all licences
To check if everything is ok run the doctor in verbos mode as following : flutter doctor -v
Here is very basic and simple solution
just change the folder structure
change main folder name to latest
then create a folder named cmdline-tools
create new folder inside cmdline called tools and put bin and other data inside tools folder
so it will look like this
user\latest\cmdline-tools\tools
I have searched alot but it worked for me
Android Studio is necessary when installing the command line tools even if it's not the editor you use to develop apps with. Unchecking the obsolete packages tab and downloading the tools should do it; that should clear the license issue and you can go back to your favorite IDE (such as VS Code).
I wanted to install the Android NDK on my Jenkins. What I normally do to install components is execute the command
android list sdk --all
and
android update sdk -u -a -t <package number>
Unfortunately android list sdk --all is not showing the NDK, CMake and LLDB sdks that I need.
Why those sdks are not showing on the sdks list?
How can I install the NDK on my Jenkins?
Thanks for the help
Instead of using the command line, you can simply download the NDK per your machine and unzip it to a directory wherever you like. NDK can be downloaded at: https://developer.android.com/ndk/downloads. All the components, e.g. NDK, CMake and LLDB are shipped inside.
Update: If you really want to go for command line approach, command sdkmanager (under directory: <your-path>/sdk/tools/bin) is the way to go.
E.g. List installed and available packages
./sdkmanager --list
To install NDK directly use below.
./sdkmanager "ndk-bundle"
./sdkmanager "lldb;3.1"
./sdkmanager "cmake;3.6.4111459"
This question already has answers here:
Automatically accept all SDK licences
(63 answers)
Closed 5 years ago.
I downloaded the latest Android SDK tools version 24.4.1. I used the command line to install SDKs. I typed y when asked
Do you accept the license 'android-sdk-license-c81a61d9' [y/n]: y
after that install succeeded.
But when using Gradle 3.1 to build, the follows shows up
You have not accepted the license agreements of the following SDK components:
[Android SDK Platform 23, Android SDK Build-Tools 23.0.1].
Before building your project, you need to accept the license agreements and complete the installation of the missing components using the Android Studio SDK Manager.
Alternatively, to learn how to transfer the license agreements from one workstation to another, go to http://d.android.com/r/studio-ui/export-licenses.html
I checked ~/.android and /opt/android-sdk where Android tools are put. Neither contain folder named licenses.
The way to accept license agreements from the command line has changed. You can use the SDK manager which is located at: $ANDROID_SDK_ROOT/tools/bin
e.g on linux:
cd ~/Library/Android/sdk/tools/bin/
Run the sdkmanager as follows:
./sdkmanager --licenses
e.g on Windows:
cd /d "%ANDROID_SDK_ROOT%/tools/bin"
Run the sdkmanager as follows:
sdkmanager --licenses
And accept the licenses you did not accept yet (but need to).
For more details see the Android Studio documentation, although the current documentation is missing any description on the --licenses option.
Warning
You might have two Android SDKs on your machine. Make sure to check both ~/Library/Android/sdk and /usr/local/share/android-sdk! If unsure, fully uninstall Android Studio from your machine and start with a clean slate.
Update: ANDROID_HOME is deprecated, ANDROID_SDK_ROOT is now the correct variable
You can install and accept the license of the SDK & tools via 2 ways:
1. Open the Android SDK Manager GUI via command line
Open the Android SDK manager via the command line using:
# Android SDK Tools 25.2.3 and lower - Open the Android SDK GUI via the command line
cd ~/Library/Android/sdk/tools && ./android
# 'Android SDK Tools' 25.2.3 and higher - `sdkmanager` is located in android_sdk/tools/bin/.
cd ~/Library/Android/sdk/tools/bin && ./sdkmanager
View more details on the new sdkmanager.
Select and install the required tools. (your location may be different)
2. Install and accept android license via command line:
Update the packages via command line, you'll be presented with the terms and conditions which you'll need to accept.
- Install or update to the latest version
This will install the latest platform-tools at the time you run it.
# Android SDK Tools 25.2.3 and lower. Install the latest `platform-tools` for android-25
android update sdk --no-ui --all --filter platform-tools,android-25,extra-android-m2repository
# Android SDK Tools 25.2.3 and higher
sdkmanager --update
- Install a specific version (25.0.1, 24.0.1, 23.0.1)
You can also install a specific version like so:
# Build Tools 23.0.1, 24.0.1, 25.0.1
android update sdk --no-ui --all --filter build-tools-25.0.1,android-25,extra-android-m2repository
android update sdk --no-ui --all --filter build-tools-24.0.1,android-24,extra-android-m2repository
android update sdk --no-ui --all --filter build-tools-23.0.1,android-23,extra-android-m2repository
# Alter the versions as required ↑ ↑
# -u --no-ui : Updates from command-line (does not display the GUI)
# -a --all : Includes all packages (such as obsolete and non-dependent ones.)
# -t --filter : A filter that limits the update to the specified types of
# packages in the form of a comma-separated list of
# [platform, system-image, tool, platform-tool, doc, sample,
# source]. This also accepts the identifiers returned by
# 'list sdk --extended'.
# List version and description of other available SDKs and tools
android list sdk --extended
sdkmanager --list
Go to your $ANDROID_HOME/tools/bin
and fire the cmd
./sdkmanager --licenses
Accept All licenses listed there.
After this just go to the licenses folder in sdk and check that it's having these five files:
android-sdk-license, android-googletv-license, android-sdk-preview-license, google-gdk-license, mips-android-sysimage-license
Give a retry and build again, still jenkins giving 'licenses not accepted' then you have to give full permission to your 'sdk' directory and all it's parent directories. Here is the command:
sudo chmod -R 777 /opt/
If you having sdk in /opt/ directory.
I have resolved the problem by using the command:
Go to: C:\Users\ [PC NAME] \AppData\Local\Android\sdk\tools\bin\ (If the folder is not available then download the Android SDK first, or
you can install it from the android studio installation process.)
Shift+Left click and Press W, then Enter to open CMD on the folder path
Type in the cmd: sdkmanager --licenses
Once press enter, you need to accept all the licenses by pressing y
Checking the licenses
Go to: C:\Users\ [PC NAME] \AppData\Local\Android\sdk\
Check the folder named licenses
android-googletv-license
android-sdk-license
android-sdk-preview-license
google-gdk-license
intel-android-extra-license
mips-android-sysimage-license
AS NEW UPDATE FOLDER PATH (Current Android Studio)
Open Android Studio, Tools > Sdk Manager > Android SDK Command-Line Tools (Just Opt-in)
SDKManager will be store in :
Go to C:\Users\ [PC NAME] \AppData\Local\Android\Sdk\cmdline-tools\latest\bin
Type in the cmd: sdkmanager --licenses
Documentation to using the Android SDK: https://developer.android.com/studio/command-line/sdkmanager.html
For Windows users w/o using Andoid Studio:
Go to the location of your sdkmanager.bat file. Per default it is at Android\sdk\tools\bin inside the %LOCALAPPDATA% folder.
Open a terminal window there by typing cmd into the title bar
Type
sdkmanager.bat --licenses
Accept all licenses with 'y'
Update for macOS Sierra 10.12.6 - Android Studio for Mac 2.3.3
Locate the sdkmanager file usually under:
/Users/YOUR_MAC_USER/Library/Android/sdk/tools/bin
./sdkmanager --licenses
Warning: File /Users/mtro.josevaler**strong text**io/.android/repositories.cfg could not be loaded.
6 of 6 SDK package licenses not accepted.
Review licenses that have not been accepted (y/N)? Y
To validate the problem has gone just repeat the operation involved in the license issue.
I solved the problem by opening the Android SDK Manager and installing the SDK build tools for the version it is complaining about (API 24).
I had also updated using the command line previously and I suspect the Android SDK Manager has a more complete way of resolving dependencies, including the license.
Maybe I'm late, but this helped me accept SDK licenses for OSX,
If you have android SDK tools installed, run the following command
~/Library/Android/sdk/tools/bin/sdkmanager --licenses
Accept all licenses by pressing y
Voila! You have accepted SDK licenses and are good to go..
If you want to use the IDE to accept the license, I also found it easy to open up Android Studio and create a new basic project to trigger the license agreements. Once I created a project, the following licensing dialog was presented that I needed to agree to:
I documented fully the information in the following post: Accepting the Android SDK License via Android Studio
I had a similiar problem but ./sdkmanager --licenses didnt work. I follow this thread and "obladors" comment gave me the solution:
https://github.com/oblador/react-native-vector-icons/issues/527
What eventually solved my problem was:
Running ./sdkmanager "build-tools;23.0.1"
Change 23.0.1 with your version
You can accept the license agreement by launching Android Studio, then going to:
Help > Check for Updates...
When you are installing updates, it'll ask you to accept the license agreement. Accept the license agreement and install the updates, and you are all set.
I ran across this error when i ran cordova build android
I solved this issue by firing ./sdkmanager --licenses and accepting all the licenses.
You have a sdkmanager.bat under the android sdk folder in the path: android/sdk/tools/bin
To trigger that open a command prompt in android/sdk/tools/bin
type ./sdkmanager --licenses and enter
Press y to review all licenses and then press y to accept all licenses
In linux
1. Open a terminal
2. Write: "cd $ANDROID_HOME/tools/bin (this path can be /home/your-user/Android/Sdk/tools/bin)"
3. Write: "./sdkmanager --licenses"
4. To accept All licenses listed, write: "y"
5. Ready!
If your are building an app with Ionic Framework, just write again the command to build it.
If you are having this problem for a React Native app, in addition to above mentioned steps, make sure you have the local.properties file in the android directory(AppName/android) of your app which points to your 'sdk' directory:
sdk.dir=/PATH_TO_SDK/
I have resolved the issue by below steps:
update the android sdk with command "tools/android update sdk --no-ui"
got to android sdk folder on jenkins machines, create "licenses" folder
created file named "android-sdk-license" and paste the license from dev machine
I want to list the installed sdk packages by command lines.(For some reasons I cannot use the GUI)
I have done some research and found out several commands to list the available packages on the remote server, but I fail to find any command to list the installed sdk packages yet.
Thanks
With Android SDK Tools 25.2.3 (and higher):
$ANDROID_HOME/tools/bin/sdkmanager --list
See: https://developer.android.com/studio/command-line/sdkmanager.html#usage
If you have your path set up, run
sdkmanager --list_installed
This will print out all the packages installed using sdkmanager.
For those want to use awk getting the inner paragraph between "Installed packages" and "Aavaliable Packages", but not include "Installed packages" and "Aavaliable Packages" lines.
sdkmanager --list | awk '/Installed/{flag=1; next} /Available/{flag=0} flag'
As described in $ANDROID_HOME/tools/android list --help
list : Lists existing targets or virtual devices.
list avd : Lists existing Android Virtual Devices.
list target : Lists existing targets.
list device : Lists existing devices.
list sdk : Lists remote SDK repository.
I guess you are looking for this:
$ANDROID_HOME/tools/android list target
You can learn more on the android tool in the Command Line Reference.
Good luck!
On my mac just sdkmanager --list was not working, path needed to be specified.
Using android studio default SDK location the path is ~/Library/Android/sdk/tools/bin/sdkmanager --list
As mentioned by #tnissi this is for Android SDK Tools 25.2.3 (and higher).
Or add the path by: export PATH=$PATH:~/Library/Android/sdk/tools/bin
in case you need only the installed packages with full names
sdkmanager --verbose --list | sed -n '/^Installed packages:$/,/^Available Packages:$/p'
It's not quite a listing, but the source.properties files give details of the provenance. I'm using this to compare SDKs on different machines:
for i in $(find -name source.properties); do
if [ -e ../other.sdk/$i ] ; then
echo ========================= $i
diff -wu $i ../other.sdk/$i | grep -v Pkg.License
fi
done
I strip Pkg.License because it's hyoooj.
A bit old topic but I had similar problem, And noticed that avdmanager lists installed platforms as targets
"%ANDROID_SDK_ROOT%\tools\bin\avdmanager" list target
Available Android targets:==============] 100% Fetch remote repository...
----------
id: 1 or "android-25"
Name: Android API 25
Type: Platform
API level: 25
Revision: 3
----------
id: 2 or "android-28"
Name: Android API 28
Type: Platform
API level: 28
Revision: 6
Now I have to download and install the Android SDK and AVD Manager, and then install the APIs, tools through the UI. Is there a way to automate this process?
UPDATE
The latest versions introduce sdkmanager, a command line tool that allows you to view, install, update, and uninstall packages for the Android SDK.
The sdkmanager tool is provided in the Android SDK Tools package (25.2.3 and higher) and is located in android_sdk/tools/bin/.
sdkmanager [--uninstall] [<common args>] [--package_file <file>] [<packages>...]
sdkmanager --update [<common args>]
sdkmanager --list [<common args>]
sdkmanager --licenses [<common args>]
In its first form, installs, or uninstalls, or updates packages.
By default, the listed packages are installed or (if already installed)
updated to the latest version.
--uninstall: uninstalled listed packages.
<package> is a sdk-style path (e.g. "build-tools;23.0.0" or
"platforms;android-23").
<package-file> is a text file where each line is a sdk-style path
of a package to install or uninstall.
Multiple --package_file arguments may be specified in combination
with explicit paths.
In its second form (with --update), all installed packages are
updated to the latest version.
In its third form, all installed and available packages are printed
out.
In its fourth form (with --licenses), show and offer the option to
accept licenses for all available packages that have not already been
accepted.
Common Arguments:
--sdk_root=<sdkRootPath>: Use the specified SDK root instead of the SDK
containing this tool
--channel=<channelId>: Include packages in channels up to <channelId>.
Common channels are:
0 (Stable), 1 (Beta), 2 (Dev), and 3 (Canary).
--include_obsolete: With --list, show obsolete packages in the
package listing. With --update, update obsolete
packages as well as non-obsolete.
--no_https: Force all connections to use http rather than https.
--proxy=<http | socks>: Connect via a proxy of the given type.
--proxy_host=<IP or DNS address>: IP or DNS address of the proxy to use.
--proxy_port=<port #>: Proxy port to connect to.
* If the env var REPO_OS_OVERRIDE is set to "windows",
"macosx", or "linux", packages will be downloaded for that OS.
So, to update the packages run
sdkmanager --update
To accept the licenses,
yes | sdkmanager --licenses
OLD ANSWER
(Please note: The android command is deprecated!)
The closer you can get to automation probably is:
android update sdk --no-ui
android provides these options for automatic updates:
Action "update sdk":
Updates the SDK by suggesting new platforms to install if available.
Options:
-f --force Forces replacement of a package or its parts, even if something has been modified
-u --no-ui Updates from command-line (does not display the GUI)
-o --obsolete Installs obsolete packages
-t --filter A filter that limits the update to the specified types of packages in the form of
a comma-separated list of [platform, tool, platform-tool, doc, sample, extra]
-s --no-https Uses HTTP instead of HTTPS (the default) for downloads
-n --dry-mode Simulates the update but does not download or install anything
If you want to list which packages are available for installation you can use
android list sdk
And you'll obtain an ordered list of packages, for example
Packages available for installation or update: 9
1- ARM EABI v7a System Image, Android API 15, revision 2
2- Intel x86 Atom System Image, Android API 15, revision 1
3- Android Support, revision 8
4- Google AdMob Ads SDK, revision 6
5- Google Analytics SDK, revision 2
6- Google Play APK Expansion Library, revision 1
7- Google Play Billing Library, revision 2
8- Google Play Licensing Library, revision 2
9- Google Web Driver, revision 2
Also you can limit the update only to a desired component if you use the --filter option
android update sdk --filter <component> --no-ui
where component is one or more of
the numbers returned by android list sdk (i.e. 1, also know as package index)
add-on
doc
extra
platform
platform-tool
sample
source
system-image
tool
Or can be one or more specific identifiers. For instance, if you just want to download a small set of specific packages, you could do this:
android update sdk -u --filter platform-tools,android-16,extra-android-support
And you'll just get the platform tools, API level 16 and support package JAR files. This is really handy if you're building a build machine only and would have to pay for downloading all the extra stuff that you'll never use.
To see the available options you can use --help, for example
android --help list sdk
Usage:
android [global options] list sdk [action options]
Global options:
-h --help : Help on a specific command.
-v --verbose : Verbose mode, shows errors, warnings and all messages.
--clear-cache: Clear the SDK Manager repository manifest cache.
-s --silent : Silent mode, shows errors only.
Action "list sdk":
Lists remote SDK repository.
Options:
-o --obsolete : Deprecated. Please use --all instead.
-a --all : Lists all available packages (including obsolete and
installed ones)
--proxy-host: HTTP/HTTPS proxy host (overrides settings if defined)
--proxy-port: HTTP/HTTPS proxy port (overrides settings if defined)
-s --no-https : Uses HTTP instead of HTTPS (the default) for downloads.
-e --extended : Displays extended details on each package
-u --no-ui : Displays list result on console (no GUI) [Default: true]
This didn't work for me...
echo "y" | android ....
So I ended up here:
expect -c '
set timeout -1 ;
spawn sudo /opt/android-sdk/tools/android update sdk -u;
expect {
"Do you accept the license" { exp_send "y\r" ; exp_continue }
eof
}
'
I use this to install and update the SDK on Travis CI:
curl --location http://dl.google.com/android/android-sdk_r22.3-linux.tgz | tar -x -z -C $HOME
export ANDROID_HOME=$HOME/android-sdk-linux
export PATH=$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools
( sleep 5 && while [ 1 ]; do sleep 1; echo y; done ) | android update sdk --no-ui --filter platform-tool,android-19,sysimg-19,build-tools-19.0.1
To answer all licenses with 'y', you can try this in the script:
(while :
do
echo 'y'
sleep 2
done) | android update sdk -u .....
For anyone still searching for a method to download all Android packages, I have wrote a script to do that. It will download all non-obsoleted packages.
#!/binbash
# Install all non-obsolete Android SDK packages.
# author: Tai Le Tien (letientai299 at gmail.com)
function install_sdk {
android update sdk -u -s -a -t "$1"
}
function fetch_non_obsoled_package_indices {
# Fetch the SDK list using non-https connections
android list sdk -u -s -a |\
# Filter obsoleted packages
sed '/\(Obsolete\)/d' |\
# Filter to take only the index number of package
sed 's/^[ ]*\([0-9]*\).*/\1/' |\
# Remove the empty lines
sed -n 's/^[^ $]/\0/p'
}
for package_index in $(fetch_non_obsoled_package_indices)
do
echo "====================================================================="
echo "Start to install package: ${package_index}"
echo "====================================================================="
# Auto accept license
echo -e "y" | install_sdk "${package_index}"
echo
echo
done
You can also see it on my GitHub repository
The good:
Not depend on expect.
Headless.
The downsides:
You still have to install basic SDK manually, and put android into your path.
The script only works on Unix.
In newer Android versions (e.g., 25.2.5) we should use sdkmanager (instead of the android command).
Example of installing a package:
android-sdk/tools/bin/sdkmanager "extras;android;m2repository"
Command to get a list of all available packages:
android-sdk/tools/bin/sdkmanager --verbose --list
This web-page lists download links for the SDK-tools:
Here is a link to an open-source repository docker-android which can install android in a Docker image.
You may also find the answers in this SO question: Automatically accept all SDK licences useful.
Starting with Android Plugin for Gradle version 2.2.0, missing SDK components get downloaded automatically.
I got frustrated with this as well and built a Gradle plugin named com.quittle.setup-android-sdk that will detect and install what you need. It works on Windows, OS X, and Linux and doesn't require any additional dependencies if you build with Gradle.
If you're interested, you can checkout my documentation on it here: https://github.com/quittle/gradle-setup-android-sdk
To automate the sdkmanager.bat --licenses prompt away on Windows (say you're installing via automation for build infrastructure)... Don't run it. Don't waste time trying to figure out how to pipe y into it. I tried; abject fail.
Rather - run it one time, yourself, and take note that it generates files into C:\android\android-sdk\licenses (where you're running C:\android\android-sdk\tools\bin\sdkmanager.bat - your install root may vary).
Take those files, and place them somewhere you can grab them from in your automated setup scripts. Personally, Ansible is my poison, so:
# Note to future-us:
# These are magical files generated by running `c:/android/android-sdk/tools/bin/sdkmanager.bat --licenses`
# This, delightfully, is interactive, and wants to _actually_ read the keyboard buffer.
# That's reputedly possible via SendKeys. I elected to not try that.
# So, instead:
# 1) remote to an instance like a cave-dweller
# 2) run `c:/android/android-sdk/tools/bin/sdkmanager.bat --licenses` in a prompt.
# 3) _actually type_ `y` however many godforsaken times you need to.
# 4) meticulously harvest `c:/android/android-sdk/licenses/*` to this task.
# (you don't need the newline that they thoughtfully put before the hash in each file).
- name: set up android licenses by hand
win_lineinfile:
path: c:/android/android-sdk/licenses/{{ item.name }}
line: "{{ item.line }}"
create: true
with_items:
- {name: "android-googletv-license", line: "SOME HASH"}
- {name: "android-sdk-license", line: "SOME OTHER HASH"}
...
A script to download only needed, non-{obsolete, source, emulator-image, doc} packages:
#!/bin/bash
set -e
# cd into where tools/android can be found
if [[ -d "$ANDROID_HOME" ]]; then
cd "$ANDROID_HOME"
elif [[ -x "$(dirname "$0")/tools/android" ]]; then
cd "$(dirname "$0")"
else
echo "FAILED: Cannot find ANDROID_HOME/tools/android"
exit 1
fi
android () {
"$(dirname $0)/tools/android" "$#"
}
needed_packages () {
android list sdk -u -s -e \
| grep '^id:' \
| cut -d'"' -f2 \
| grep -v 'source' \
| grep -v 'sys-img' \
| grep -v 'doc' \
| paste -d, -s -
}
main () {
(while : ; do
echo 'y'
sleep 1
done) | android update sdk -u -s -a -t "$(needed_packages)"
}
main
Some parts are taken from other answers.
For a newbie Android developer, but an experienced Java developer, it is really bewildering to know which dependencies, even if you get past all of the nightmares in the previous answers.
A colleague of mine advised me to use Android Studio (which is IntelliJ IDEA based :-) specifically because of the above nightmares.
I followed his advice.
But I did not accept the defaults for the installation, and tried to install it in a software drive of mine. It turned out to be a nightmare. The SDK dialogue seemed to hang and was not intuitive at all. Which is why I ended up here.
After reading the above, I gave Studio another try, and this time it accepted all the defaults for the installation.
Hey PRESTO...it took care of all the SDK dependencies (core ones I am guessing) in a couple of dialogues without being prompted i.e., Ctrl + Shift + S and the SDK.
I would therefore recommend it for a newbie. Here the proof of the pudding as it downloads:
The version of Studio I downloaded and installed:
Version of windows:
And here after it did its good stuff: