/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.tools.idea.stats;
import com.intellij.openapi.diagnostic.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.*;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Utility class to send "ping" usage reports to the server.
* Imported from the android/tools/swt/sdkstats project, and simplified for usage in Studio.
* */
@SuppressWarnings("MethodMayBeStatic")
public class LegacySdkStatsService {
private static final Logger LOG = Logger.getInstance("#" + LegacySdkStatsService.class.getName());
protected static final String SYS_PROP_OS_ARCH = "os.arch"; //$NON-NLS-1$
protected static final String SYS_PROP_JAVA_VERSION = "java.version"; //$NON-NLS-1$
protected static final String SYS_PROP_OS_VERSION = "os.version"; //$NON-NLS-1$
protected static final String SYS_PROP_OS_NAME = "os.name"; //$NON-NLS-1$
/** Minimum interval between ping, in milliseconds. */
private static final long PING_INTERVAL_MSEC = 86400 * 1000; // 1 day
private static final boolean DEBUG = System.getenv("ANDROID_DEBUG_PING") != null; //$NON-NLS-1$
private DdmsPreferenceStore mStore = new DdmsPreferenceStore();
public LegacySdkStatsService() {
}
/**
* Send a "ping" to the Google toolbar server, if enough time has
* elapsed since the last ping, and if the user has not opted out.
* <p/>
* This is a simplified version of {@link #ping(String[])} that only
* sends an "application" name and a "version" string. See the explanation
* there for details.
*
* @param app The application name that reports the ping (e.g. "emulator" or "ddms".)
* Valid characters are a-zA-Z0-9 only.
* @param version The version string (e.g. "12" or "1.2.3.4", 4 groups max.)
*/
public void ping(@NotNull String app, @NotNull String version) {
doPing(app, version, null);
}
// -------
/**
* Pings the usage stats server, as long as the prefs contain the opt-in boolean
*
* @param app The application name that reports the ping (e.g. "emulator" or "ddms".)
* Will be normalized. Valid characters are a-zA-Z0-9 only.
* @param version The version string (e.g. "12" or "1.2.3.4", 4 groups max.)
* @param extras Extra key/value parameters to send. They are send as-is and must
* already be well suited and escaped using {@link java.net.URLEncoder#encode(String, String)}.
*/
protected void doPing(@NotNull String app,
@NotNull String version,
@Nullable final Map<String, String> extras) {
// Note: if you change the implementation here, you also need to change
// the overloaded SdkStatsServiceTest.doPing() used for testing.
// Validate the application and version input.
final String nApp = normalizeAppName(app);
final String nVersion = normalizeVersion(version);
// If the user has not opted in, do nothing and quietly return.
if (!mStore.isPingOptIn()) {
// user opted out.
return;
}
// If the last ping *for this app* was too recent, do nothing.
long now = System.currentTimeMillis();
long then = mStore.getPingTime(app);
if (now - then < PING_INTERVAL_MSEC) {
// too soon after a ping.
return;
}
// Record the time of the attempt, whether or not it succeeds.
mStore.setPingTime(app, now);
// Send the ping itself in the background (don't block if the
// network is down or slow or confused).
long id = mStore.getPingId();
if (id == 0) {
id = mStore.generateNewPingId();
}
try {
URL url = createPingUrl(nApp, nVersion, id, extras);
actuallySendPing(url);
} catch (Exception e) {
LOG.warn("AndroidSdk.SendPing failed", e);
}
}
/**
* Unconditionally send a "ping" request to the server.
*
* @param url The URL to send to the server.
* * @throws IOException if the ping failed
*/
private void actuallySendPing(URL url) throws IOException {
assert url != null;
if (DEBUG) {
LOG.debug("Ping: " + url.toString()); //$NON-NLS-1$
}
// Discard the actual response, but make sure it reads OK
HttpURLConnection conn = (HttpURLConnection)url.openConnection();
int responseCode;
try {
responseCode = conn.getResponseCode();
}
catch (UnknownHostException e) {
responseCode = HttpURLConnection.HTTP_BAD_REQUEST;
}
// Believe it or not, a 404 response indicates success:
// the ping was logged, but no update is configured.
if (responseCode != HttpURLConnection.HTTP_OK &&
responseCode != HttpURLConnection.HTTP_NOT_FOUND) {
throw new IOException(conn.getResponseMessage() + ": " + url); //$NON-NLS-1$
}
}
/**
* Compute the ping URL to send the data to the server.
*
* @param app The application name that reports the ping (e.g. "emulator" or "ddms".)
* Valid characters are a-zA-Z0-9 only.
* @param version The version string already formatted as a 4 dotted group (e.g. "1.2.3.4".)
* @param id of the local installation
* @param extras Extra key/value parameters to send. They are send as-is and must
* already be well suited and escaped using {@link java.net.URLEncoder#encode(String, String)}.
*/
protected URL createPingUrl(@NotNull String app,
@NotNull String version,
long id,
@Nullable Map<String, String> extras)
throws UnsupportedEncodingException, MalformedURLException {
String osName = URLEncoder.encode(getOsName().getOsFull(), "UTF-8"); //$NON-NLS-1$
String osArch = URLEncoder.encode(getOsArch(), "UTF-8"); //$NON-NLS-1$
String jvmArch = URLEncoder.encode(getJvmInfo(), "UTF-8"); //$NON-NLS-1$
// Include the application's name as part of the as= value.
// Share the user ID for all apps, to allow unified activity reports.
String extraStr = ""; //$NON-NLS-1$
if (extras != null && !extras.isEmpty()) {
StringBuilder sb = new StringBuilder();
for (Map.Entry<String, String> entry : extras.entrySet()) {
sb.append('&').append(entry.getKey()).append('=').append(entry.getValue());
}
extraStr = sb.toString();
}
//noinspection UnnecessaryLocalVariable
URL url = new URL("http", //$NON-NLS-1$
"tools.google.com", //$NON-NLS-1$
"/service/update?as=androidsdk_" + app + //$NON-NLS-1$
"&id=" + Long.toHexString(id) + //$NON-NLS-1$
"&version=" + version + //$NON-NLS-1$
"&os=" + osName + //$NON-NLS-1$
"&osa=" + osArch + //$NON-NLS-1$
"&vma=" + jvmArch + //$NON-NLS-1$
extraStr);
return url;
}
/**
* Detects and reports the host OS: "linux", "win" or "mac".
* For Windows and Mac also append the version, so for example
* Win XP will return win-5.1.
*/
OsInfo getOsName() { // made protected for testing
String os = getSystemProperty(SYS_PROP_OS_NAME);
OsInfo info = new OsInfo();
if (os == null || os.length() == 0) {
return info.setOsName("unknown");
}
String os2 = os.toLowerCase(Locale.US);
String osVers = null;
if (os2.startsWith("mac")) {
os = "mac";
osVers = getOsVersion();
}
else if (os2.startsWith("win")) {
os = "win";
osVers = getOsVersion();
}
else if (os2.startsWith("linux")) {
os = "linux";
}
else if (os.length() > 32) {
// Unknown -- send it verbatim so we can see it
// but protect against arbitrarily long values
os = os.substring(0, 32);
}
info.setOsName(os);
info.setOsVersion(osVers);
return info;
}
/**
* Detects and returns the OS architecture: x86, x86_64, ppc.
* This may differ or be equal to the JVM architecture in the sense that
* a 64-bit OS can run a 32-bit JVM.
*/
String getOsArch() { // made protected for testing
String arch = getJvmArch();
if ("x86_64".equals(arch)) { //$NON-NLS-1$
// This is a simple case: the JVM runs in 64-bit so the
// OS must be a 64-bit one.
return arch;
}
else if ("x86".equals(arch)) { //$NON-NLS-1$
// This is the misleading case: the JVM is 32-bit but the OS
// might be either 32 or 64. We can't tell just from this
// property.
// Macs are always on 64-bit, so we just need to figure it
// out for Windows and Linux.
String os = getOsName().getOsName();
if (os.startsWith("win")) { //$NON-NLS-1$
// When WOW64 emulates a 32-bit environment under a 64-bit OS,
// it sets PROCESSOR_ARCHITEW6432 to AMD64 or IA64 accordingly.
// Ref: http://msdn.microsoft.com/en-us/library/aa384274(v=vs.85).aspx
String w6432 = getSystemEnv("PROCESSOR_ARCHITEW6432"); //$NON-NLS-1$
if (w6432 != null && w6432.contains("64")) { //$NON-NLS-1$
return "x86_64"; //$NON-NLS-1$
}
}
else if (os.startsWith("linux")) { //$NON-NLS-1$
// Let's try the obvious. This works in Ubuntu and Debian
String s = getSystemEnv("HOSTTYPE"); //$NON-NLS-1$
s = sanitizeOsArch(s);
if (s.contains("86")) { //$NON-NLS-1$
arch = s;
}
}
}
return arch;
}
/**
* Returns the version of the OS version if it is defined as X.Y, or null otherwise.
* <p/>
* Example of returned versions can be found at http://lopica.sourceforge.net/os.html
* <p/>
* This method removes any exiting micro versions.
* Returns null if the version doesn't match X.Y.Z.
*/
@Nullable
String getOsVersion() { // made protected for testing
Pattern p = Pattern.compile("(\\d+)\\.(\\d+).*"); //$NON-NLS-1$
String osVers = getSystemProperty(SYS_PROP_OS_VERSION);
if (osVers != null && osVers.length() > 0) {
Matcher m = p.matcher(osVers);
if (m.matches()) {
return m.group(1) + '.' + m.group(2);
}
}
return null;
}
/**
* Detects and returns the JVM info: version + architecture.
* Examples: 1.4-ppc, 1.6-x86, 1.7-x86_64
*/
String getJvmInfo() { // made protected for testing
return getJvmVersion() + '-' + getJvmArch();
}
/**
* Returns the major.minor Java version.
* <p/>
* The "java.version" property returns something like "1.6.0_20"
* of which we want to return "1.6".
*/
String getJvmVersion() { // made protected for testing
String version = getSystemProperty(SYS_PROP_JAVA_VERSION);
if (version == null || version.length() == 0) {
return "unknown"; //$NON-NLS-1$
}
Pattern p = Pattern.compile("(\\d+)\\.(\\d+).*"); //$NON-NLS-1$
Matcher m = p.matcher(version);
if (m.matches()) {
return m.group(1) + '.' + m.group(2);
}
// Unknown version. Send it as-is within a reasonable size limit.
if (version.length() > 8) {
version = version.substring(0, 8);
}
return version;
}
/**
* Detects and returns the JVM architecture.
* <p/>
* The HotSpot JVM has a private property for this, "sun.arch.data.model",
* which returns either "32" or "64". However it's not in any kind of spec.
* <p/>
* What we want is to know whether the JVM is running in 32-bit or 64-bit and
* the best indicator is to use the "os.arch" property.
* - On a 32-bit system, only a 32-bit JVM can run so it will be x86 or ppc.<br/>
* - On a 64-bit system, a 32-bit JVM will also return x86 since the OS needs
* to masquerade as a 32-bit OS for backward compatibility.<br/>
* - On a 64-bit system, a 64-bit JVM will properly return x86_64.
* <pre>
* JVM: Java 32-bit Java 64-bit
* Windows: x86 x86_64
* Linux: x86 x86_64
* Mac untested x86_64
* </pre>
*/
String getJvmArch() { // made protected for testing
String arch = getSystemProperty(SYS_PROP_OS_ARCH);
return sanitizeOsArch(arch);
}
private String sanitizeOsArch(String arch) {
if (arch == null || arch.length() == 0) {
return "unknown"; //$NON-NLS-1$
}
if (arch.equalsIgnoreCase("x86_64") || //$NON-NLS-1$
arch.equalsIgnoreCase("ia64") || //$NON-NLS-1$
arch.equalsIgnoreCase("amd64")) { //$NON-NLS-1$
return "x86_64"; //$NON-NLS-1$
}
if (arch.length() >= 4 && arch.charAt(0) == 'i' && arch.indexOf("86") == 2) { //$NON-NLS-1$
// Any variation of iX86 counts as x86 (i386, i486, i686).
return "x86"; //$NON-NLS-1$
}
if (arch.equalsIgnoreCase("PowerPC")) { //$NON-NLS-1$
return "ppc"; //$NON-NLS-1$
}
// Unknown arch. Send it as-is but protect against arbitrarily long values.
if (arch.length() > 32) {
arch = arch.substring(0, 32);
}
return arch;
}
/**
* Normalize the supplied application name.
*
* @param app to report
*/
protected String normalizeAppName(String app) {
// Filter out \W , non-word character: [^a-zA-Z_0-9]
String app2 = app.replaceAll("\\W", ""); //$NON-NLS-1$ //$NON-NLS-2$
if (app.length() == 0) {
throw new IllegalArgumentException("Bad app name: " + app); //$NON-NLS-1$
}
return app2;
}
/**
* Validate the supplied application version, and normalize the version.
*
* @param version supplied by caller
* @return normalized dotted quad version
*/
protected String normalizeVersion(String version) {
Pattern regex = Pattern.compile(
//1=major 2=minor 3=micro 4=build | 5=rc
"^(\\d+)(?:\\.(\\d+))?(?:\\.(\\d+))?(?:\\.(\\d+)| +rc(\\d+))?"); //$NON-NLS-1$
Matcher m = regex.matcher(version);
if (m != null && m.lookingAt()) {
StringBuilder normal = new StringBuilder();
for (int i = 1; i <= 4; i++) {
int v = 0;
// If build is null but we have an rc, take that number instead as the 4th part.
if (i == 4 &&
i < m.groupCount() &&
m.group(i) == null &&
m.group(i + 1) != null) {
//noinspection AssignmentToForLoopParameter
i++;
}
if (m.group(i) != null) {
try {
v = Integer.parseInt(m.group(i));
} catch (Exception ignore) {
}
}
if (i > 1) {
normal.append('.');
}
normal.append(v);
}
return normal.toString();
}
throw new IllegalArgumentException("Bad version: " + version); //$NON-NLS-1$
}
/**
* Calls {@link System#getProperty(String)}.
* Allows unit-test to override the return value.
* @see System#getProperty(String)
*/
protected String getSystemProperty(String name) {
return System.getProperty(name);
}
/**
* Calls {@link System#getenv(String)}.
* Allows unit-test to override the return value.
* @see System#getenv(String)
*/
protected String getSystemEnv(String name) {
return System.getenv(name);
}
}