/*
* 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.sdkstats;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Arrays;
import java.util.HashMap;
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. */
public class SdkStatsService {
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 SdkStatsService() {
}
/**
* 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.)
* @see #ping(String[])
*/
public void ping(String app, String version) {
doPing(app, version, null);
}
/**
* 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/>
* The ping will not be sent if the user opt out dialog has not been shown yet.
* Use {@link #checkUserPermissionForPing(Shell)} to display the dialog requesting
* user permissions.
* <p/>
* Note: The actual ping (if any) is sent in a <i>non-daemon</i> background thread.
* <p/>
* The arguments are defined as follow:
* <ul>
* <li>Argument 0 is the "ping" command and is ignored.</li>
* <li>Argument 1 is the application name that reports the ping (e.g. "emulator" or "ddms".)
* Valid characters are a-zA-Z0-9 only.</li>
* <li>Argument 2 is the version string (e.g. "12" or "1.2.3.4", 4 groups max.)</li>
* <li>Arguments 3+ are optional and depend on the application name.</li>
* <li>"emulator" application currently has 3 optional arguments:
* <ul>
* <li>Arugment 3: android_gl_vendor</li>
* <li>Arugment 4: android_gl_renderer</li>
* <li>Arugment 5: android_gl_version</li>
* </ul>
* </li>
* </ul>
*
* @param arguments A non-empty non-null array of arguments to the ping as described above.
*/
public void ping(String[] arguments) {
if (arguments == null || arguments.length < 3) {
throw new IllegalArgumentException(
"Invalid ping arguments: expected ['ping', app, version] but got " +
(arguments == null ? "null" : Arrays.toString(arguments)));
}
int len = arguments.length;
String app = arguments[1];
String version = arguments[2];
Map<String, String> extras = new HashMap<String, String>();
if ("emulator".equals(app)) { //$NON-NLS-1$
if (len > 3) {
extras.put("glm", sanitizeGlArg(arguments[3])); //$NON-NLS-1$ vendor
}
if (len > 4) {
extras.put("glr", sanitizeGlArg(arguments[4])); //$NON-NLS-1$ renderer
}
if (len > 5) {
extras.put("glv", sanitizeGlArg(arguments[5])); //$NON-NLS-1$ version
}
}
doPing(app, version, extras);
}
private String sanitizeGlArg(String arg) {
if (arg == null) {
arg = ""; //$NON-NLS-1$
} else {
try {
arg = arg.trim();
arg = arg.replaceAll("[^A-Za-z0-9\\s_()./-]", " "); //$NON-NLS-1$ //$NON-NLS-2$
arg = arg.replaceAll("\\s\\s+", " "); //$NON-NLS-1$ //$NON-NLS-2$
// Guard from arbitrarily long parameters
if (arg.length() > 128) {
arg = arg.substring(0, 128);
}
arg = URLEncoder.encode(arg, "UTF-8"); //$NON-NLS-1$
} catch (UnsupportedEncodingException e) {
arg = ""; //$NON-NLS-1$
}
}
return arg;
}
/**
* Display a dialog to the user providing information about the ping service,
* and whether they'd like to opt-out of it.
*
* Once the dialog has been shown, it sets a preference internally indicating
* that the user has viewed this dialog.
*/
public void checkUserPermissionForPing(Shell parent) {
if (!mStore.hasPingId()) {
askUserPermissionForPing(parent);
mStore.generateNewPingId();
}
}
/**
* Prompt the user for whether they want to opt out of reporting, and save the user
* input in preferences.
*/
private void askUserPermissionForPing(final Shell parent) {
final Display display = parent.getDisplay();
display.syncExec(new Runnable() {
@Override
public void run() {
SdkStatsPermissionDialog dialog = new SdkStatsPermissionDialog(parent);
dialog.open();
mStore.setPingOptIn(dialog.getPingUserPreference());
}
});
}
// -------
/**
* 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 URLEncoder#encode(String, String)}.
*/
protected void doPing(String app, String version, 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).
final long id = mStore.getPingId();
new Thread() {
@Override
public void run() {
try {
URL url = createPingUrl(nApp, nVersion, id, extras);
actuallySendPing(url);
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
}
/**
* 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) {
System.err.println("Ping: " + url.toString()); //$NON-NLS-1$
}
// Discard the actual response, but make sure it reads OK
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// Believe it or not, a 404 response indicates success:
// the ping was logged, but no update is configured.
if (conn.getResponseCode() != HttpURLConnection.HTTP_OK &&
conn.getResponseCode() != 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 URLEncoder#encode(String, String)}.
*/
protected URL createPingUrl(String app, String version, long id, Map<String, String> extras)
throws UnsupportedEncodingException, MalformedURLException {
String osName = URLEncoder.encode(getOsName(), "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();
}
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.
*/
protected String getOsName() { // made protected for testing
String os = getSystemProperty(SYS_PROP_OS_NAME);
if (os == null || os.length() == 0) {
return "unknown"; //$NON-NLS-1$
}
String os2 = os.toLowerCase(Locale.US);
if (os2.startsWith("mac")) { //$NON-NLS-1$
os = "mac"; //$NON-NLS-1$
String osVers = getOsVersion();
if (osVers != null) {
os = os + '-' + osVers;
}
} else if (os2.startsWith("win")) { //$NON-NLS-1$
os = "win"; //$NON-NLS-1$
String osVers = getOsVersion();
if (osVers != null) {
os = os + '-' + osVers;
}
} else if (os2.startsWith("linux")) { //$NON-NLS-1$
os = "linux"; //$NON-NLS-1$
} 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);
}
return os;
}
/**
* 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.
*/
protected 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();
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.indexOf("64") != -1) { //$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.indexOf("86") != -1) { //$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.
*/
protected 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
*/
protected 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".
*/
protected 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>
*/
protected 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) {
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);
}
}