LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add browseable samples for Clockwork Beryl

Browse Source 
Bug: 17473824
Change-Id: Id4c637733c491ac71bb6e269f55939c082fb0994
This commit is contained in:
Trevor Johns
2014-10-22 20:10:29 -07:00
parent 4a5ce9aedf
commit f420ff0d80
797 changed files with 34843 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
samples/browseable/SpeedTracker/Application/src/com.example.android.common/activities/SampleActivityBase.java Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2013 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.example.android.common.activities;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import com.example.android.common.logger.Log;
import com.example.android.common.logger.LogWrapper;
/**
* Base launcher activity, to handle most of the common plumbing for samples.
*/
public class SampleActivityBase extends FragmentActivity {
public static final String TAG = "SampleActivityBase";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
protected void onStart() {
super.onStart();
initializeLogging();
}
/** Set up targets to receive log data */
public void initializeLogging() {
// Using Log, front-end to the logging chain, emulates android.util.log method signatures.
// Wraps Android's native log framework
LogWrapper logWrapper = new LogWrapper();
Log.setLogNode(logWrapper);
Log.i(TAG, "Ready");
}
}

236
samples/browseable/SpeedTracker/Application/src/com.example.android.common/logger/Log.java Normal file
View File

@@ -0,0 +1,236 @@
/*
* Copyright (C) 2013 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.example.android.common.logger;
/**
* Helper class for a list (or tree) of LoggerNodes.
*
* <p>When this is set as the head of the list,
* an instance of it can function as a drop-in replacement for {@link android.util.Log}.
* Most of the methods in this class server only to map a method call in Log to its equivalent
* in LogNode.</p>
*/
public class Log {
// Grabbing the native values from Android's native logging facilities,
// to make for easy migration and interop.
public static final int NONE = -1;
public static final int VERBOSE = android.util.Log.VERBOSE;
public static final int DEBUG = android.util.Log.DEBUG;
public static final int INFO = android.util.Log.INFO;
public static final int WARN = android.util.Log.WARN;
public static final int ERROR = android.util.Log.ERROR;
public static final int ASSERT = android.util.Log.ASSERT;
// Stores the beginning of the LogNode topology.
private static LogNode mLogNode;
/**
* Returns the next LogNode in the linked list.
*/
public static LogNode getLogNode() {
return mLogNode;
}
/**
* Sets the LogNode data will be sent to.
*/
public static void setLogNode(LogNode node) {
mLogNode = node;
}
/**
* Instructs the LogNode to print the log data provided. Other LogNodes can
* be chained to the end of the LogNode as desired.
*
* @param priority Log level of the data being logged. Verbose, Error, etc.
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void println(int priority, String tag, String msg, Throwable tr) {
if (mLogNode != null) {
mLogNode.println(priority, tag, msg, tr);
}
}
/**
* Instructs the LogNode to print the log data provided. Other LogNodes can
* be chained to the end of the LogNode as desired.
*
* @param priority Log level of the data being logged. Verbose, Error, etc.
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged. The actual message to be logged.
*/
public static void println(int priority, String tag, String msg) {
println(priority, tag, msg, null);
}
/**
* Prints a message at VERBOSE priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void v(String tag, String msg, Throwable tr) {
println(VERBOSE, tag, msg, tr);
}
/**
* Prints a message at VERBOSE priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
*/
public static void v(String tag, String msg) {
v(tag, msg, null);
}
/**
* Prints a message at DEBUG priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void d(String tag, String msg, Throwable tr) {
println(DEBUG, tag, msg, tr);
}
/**
* Prints a message at DEBUG priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
*/
public static void d(String tag, String msg) {
d(tag, msg, null);
}
/**
* Prints a message at INFO priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void i(String tag, String msg, Throwable tr) {
println(INFO, tag, msg, tr);
}
/**
* Prints a message at INFO priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
*/
public static void i(String tag, String msg) {
i(tag, msg, null);
}
/**
* Prints a message at WARN priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void w(String tag, String msg, Throwable tr) {
println(WARN, tag, msg, tr);
}
/**
* Prints a message at WARN priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
*/
public static void w(String tag, String msg) {
w(tag, msg, null);
}
/**
* Prints a message at WARN priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void w(String tag, Throwable tr) {
w(tag, null, tr);
}
/**
* Prints a message at ERROR priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void e(String tag, String msg, Throwable tr) {
println(ERROR, tag, msg, tr);
}
/**
* Prints a message at ERROR priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
*/
public static void e(String tag, String msg) {
e(tag, msg, null);
}
/**
* Prints a message at ASSERT priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void wtf(String tag, String msg, Throwable tr) {
println(ASSERT, tag, msg, tr);
}
/**
* Prints a message at ASSERT priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged.
*/
public static void wtf(String tag, String msg) {
wtf(tag, msg, null);
}
/**
* Prints a message at ASSERT priority.
*
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public static void wtf(String tag, Throwable tr) {
wtf(tag, null, tr);
}
}

109
samples/browseable/SpeedTracker/Application/src/com.example.android.common/logger/LogFragment.java Normal file
View File

@@ -0,0 +1,109 @@
/*
* Copyright 2013 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.
*/
/*
* Copyright 2013 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.example.android.common.logger;
import android.graphics.Typeface;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ScrollView;
/**
* Simple fraggment which contains a LogView and uses is to output log data it receives
* through the LogNode interface.
*/
public class LogFragment extends Fragment {
private LogView mLogView;
private ScrollView mScrollView;
public LogFragment() {}
public View inflateViews() {
mScrollView = new ScrollView(getActivity());
ViewGroup.LayoutParams scrollParams = new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT);
mScrollView.setLayoutParams(scrollParams);
mLogView = new LogView(getActivity());
ViewGroup.LayoutParams logParams = new ViewGroup.LayoutParams(scrollParams);
logParams.height = ViewGroup.LayoutParams.WRAP_CONTENT;
mLogView.setLayoutParams(logParams);
mLogView.setClickable(true);
mLogView.setFocusable(true);
mLogView.setTypeface(Typeface.MONOSPACE);
// Want to set padding as 16 dips, setPadding takes pixels. Hooray math!
int paddingDips = 16;
double scale = getResources().getDisplayMetrics().density;
int paddingPixels = (int) ((paddingDips * (scale)) + .5);
mLogView.setPadding(paddingPixels, paddingPixels, paddingPixels, paddingPixels);
mLogView.setCompoundDrawablePadding(paddingPixels);
mLogView.setGravity(Gravity.BOTTOM);
mLogView.setTextAppearance(getActivity(), android.R.style.TextAppearance_Holo_Medium);
mScrollView.addView(mLogView);
return mScrollView;
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View result = inflateViews();
mLogView.addTextChangedListener(new TextWatcher() {
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {}
@Override
public void afterTextChanged(Editable s) {
mScrollView.fullScroll(ScrollView.FOCUS_DOWN);
}
});
return result;
}
public LogView getLogView() {
return mLogView;
}
}

39
samples/browseable/SpeedTracker/Application/src/com.example.android.common/logger/LogNode.java Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright (C) 2012 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.example.android.common.logger;
/**
* Basic interface for a logging system that can output to one or more targets.
* Note that in addition to classes that will output these logs in some format,
* one can also implement this interface over a filter and insert that in the chain,
* such that no targets further down see certain data, or see manipulated forms of the data.
* You could, for instance, write a "ToHtmlLoggerNode" that just converted all the log data
* it received to HTML and sent it along to the next node in the chain, without printing it
* anywhere.
*/
public interface LogNode {
/**
* Instructs first LogNode in the list to print the log data provided.
* @param priority Log level of the data being logged. Verbose, Error, etc.
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged. The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
public void println(int priority, String tag, String msg, Throwable tr);
}

145
samples/browseable/SpeedTracker/Application/src/com.example.android.common/logger/LogView.java Normal file
View File

@@ -0,0 +1,145 @@
/*
* Copyright (C) 2013 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.example.android.common.logger;
import android.app.Activity;
import android.content.Context;
import android.util.*;
import android.widget.TextView;
/** Simple TextView which is used to output log data received through the LogNode interface.
*/
public class LogView extends TextView implements LogNode {
public LogView(Context context) {
super(context);
}
public LogView(Context context, AttributeSet attrs) {
super(context, attrs);
}
public LogView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
}
/**
* Formats the log data and prints it out to the LogView.
* @param priority Log level of the data being logged. Verbose, Error, etc.
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged. The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
@Override
public void println(int priority, String tag, String msg, Throwable tr) {
String priorityStr = null;
// For the purposes of this View, we want to print the priority as readable text.
switch(priority) {
case android.util.Log.VERBOSE:
priorityStr = "VERBOSE";
break;
case android.util.Log.DEBUG:
priorityStr = "DEBUG";
break;
case android.util.Log.INFO:
priorityStr = "INFO";
break;
case android.util.Log.WARN:
priorityStr = "WARN";
break;
case android.util.Log.ERROR:
priorityStr = "ERROR";
break;
case android.util.Log.ASSERT:
priorityStr = "ASSERT";
break;
default:
break;
}
// Handily, the Log class has a facility for converting a stack trace into a usable string.
String exceptionStr = null;
if (tr != null) {
exceptionStr = android.util.Log.getStackTraceString(tr);
}
// Take the priority, tag, message, and exception, and concatenate as necessary
// into one usable line of text.
final StringBuilder outputBuilder = new StringBuilder();
String delimiter = "\t";
appendIfNotNull(outputBuilder, priorityStr, delimiter);
appendIfNotNull(outputBuilder, tag, delimiter);
appendIfNotNull(outputBuilder, msg, delimiter);
appendIfNotNull(outputBuilder, exceptionStr, delimiter);
// In case this was originally called from an AsyncTask or some other off-UI thread,
// make sure the update occurs within the UI thread.
((Activity) getContext()).runOnUiThread( (new Thread(new Runnable() {
@Override
public void run() {
// Display the text we just generated within the LogView.
appendToLog(outputBuilder.toString());
}
})));
if (mNext != null) {
mNext.println(priority, tag, msg, tr);
}
}
public LogNode getNext() {
return mNext;
}
public void setNext(LogNode node) {
mNext = node;
}
/** Takes a string and adds to it, with a separator, if the bit to be added isn't null. Since
* the logger takes so many arguments that might be null, this method helps cut out some of the
* agonizing tedium of writing the same 3 lines over and over.
* @param source StringBuilder containing the text to append to.
* @param addStr The String to append
* @param delimiter The String to separate the source and appended strings. A tab or comma,
* for instance.
* @return The fully concatenated String as a StringBuilder
*/
private StringBuilder appendIfNotNull(StringBuilder source, String addStr, String delimiter) {
if (addStr != null) {
if (addStr.length() == 0) {
delimiter = "";
}
return source.append(addStr).append(delimiter);
}
return source;
}
// The next LogNode in the chain.
LogNode mNext;
/** Outputs the string as a new line of log data in the LogView. */
public void appendToLog(String s) {
append("\n" + s);
}
}

75
samples/browseable/SpeedTracker/Application/src/com.example.android.common/logger/LogWrapper.java Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright (C) 2012 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.example.android.common.logger;
import android.util.Log;
/**
* Helper class which wraps Android's native Log utility in the Logger interface. This way
* normal DDMS output can be one of the many targets receiving and outputting logs simultaneously.
*/
public class LogWrapper implements LogNode {
// For piping: The next node to receive Log data after this one has done its work.
private LogNode mNext;
/**
* Returns the next LogNode in the linked list.
*/
public LogNode getNext() {
return mNext;
}
/**
* Sets the LogNode data will be sent to..
*/
public void setNext(LogNode node) {
mNext = node;
}
/**
* Prints data out to the console using Android's native log mechanism.
* @param priority Log level of the data being logged. Verbose, Error, etc.
* @param tag Tag for for the log data. Can be used to organize log statements.
* @param msg The actual message to be logged. The actual message to be logged.
* @param tr If an exception was thrown, this can be sent along for the logging facilities
* to extract and print useful information.
*/
@Override
public void println(int priority, String tag, String msg, Throwable tr) {
// There actually are log methods that don't take a msg parameter. For now,
// if that's the case, just convert null to the empty string and move on.
String useMsg = msg;
if (useMsg == null) {
useMsg = "";
}
// If an exeption was provided, convert that exception to a usable string and attach
// it to the end of the msg method.
if (tr != null) {
msg += "\n" + Log.getStackTraceString(tr);
}
// This is functionally identical to Log.x(tag, useMsg);
// For instance, if priority were Log.VERBOSE, this would be the same as Log.v(tag, useMsg)
Log.println(priority, tag, useMsg);
// If this isn't the last node in the chain, move things along.
if (mNext != null) {
mNext.println(priority, tag, msg, tr);
}
}
}

60
samples/browseable/SpeedTracker/Application/src/com.example.android.common/logger/MessageOnlyLogFilter.java Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright (C) 2013 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.example.android.common.logger;
/**
* Simple {@link LogNode} filter, removes everything except the message.
* Useful for situations like on-screen log output where you don't want a lot of metadata displayed,
* just easy-to-read message updates as they're happening.
*/
public class MessageOnlyLogFilter implements LogNode {
LogNode mNext;
/**
* Takes the "next" LogNode as a parameter, to simplify chaining.
*
* @param next The next LogNode in the pipeline.
*/
public MessageOnlyLogFilter(LogNode next) {
mNext = next;
}
public MessageOnlyLogFilter() {
}
@Override
public void println(int priority, String tag, String msg, Throwable tr) {
if (mNext != null) {
getNext().println(Log.NONE, null, msg, null);
}
}
/**
* Returns the next LogNode in the chain.
*/
public LogNode getNext() {
return mNext;
}
/**
* Sets the LogNode data will be sent to..
*/
public void setNext(LogNode node) {
mNext = node;
}
}

95
samples/browseable/SpeedTracker/Application/src/com.example.android.wearable.speedtracker/LocationDataManager.java Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright (C) 2014 Google Inc. All Rights Reserved.
*
* 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.example.android.wearable.speedtracker;
import com.example.android.wearable.speedtracker.common.LocationEntry;
import com.example.android.wearable.speedtracker.common.Utils;
import com.example.android.wearable.speedtracker.db.LocationDbHelper;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* A class that wraps database access and provides a cache for various GPS data.
*/
public class LocationDataManager {
private final Map<String, List<LocationEntry>> mPointsMap =
new HashMap<String, List<LocationEntry>>();
private LocationDbHelper mDbHelper;
public LocationDataManager(LocationDbHelper dbHelper) {
mDbHelper = dbHelper;
}
/**
* Returns a list of {@link com.example.android.wearable.speedtracker.common.LocationEntry}
* objects for the day that the {@link java.util.Calendar} object points at. Internally it uses
* a cache to speed up subsequent calls. If there is no cached value, it gets the result from
* the database.
*/
public final List<LocationEntry> getPoints(Calendar calendar) {
String day = Utils.getHashedDay(calendar);
synchronized (mPointsMap) {
if (mPointsMap.get(day) == null) {
// there is no cache for this day, so lets get it from DB
List<LocationEntry> points = mDbHelper.read(calendar);
mPointsMap.put(day, points);
}
}
return mPointsMap.get(day);
}
/**
* Clears the data for the day that the {@link java.util.Calendar} object falls on. This method
* removes the entries from the database and updates the cache accordingly.
*/
public final int clearPoints(Calendar calendar) {
synchronized (mPointsMap) {
String day = Utils.getHashedDay(calendar);
mPointsMap.remove(day);
return mDbHelper.delete(day);
}
}
/**
* Adds a {@link com.example.android.wearable.speedtracker.common.LocationEntry} point to the
* database and cache if it is a new point.
*/
public final void addPoint(LocationEntry entry) {
synchronized (mPointsMap) {
List<LocationEntry> points = getPoints(entry.calendar);
if (points == null || points.isEmpty()) {
mDbHelper.insert(entry);
if (points == null) {
points = new ArrayList<LocationEntry>();
}
points.add(entry);
mPointsMap.put(entry.day, points);
} else {
if (!points.contains(entry)) {
mDbHelper.insert(entry);
points.add(entry);
}
}
}
}
}

43
samples/browseable/SpeedTracker/Application/src/com.example.android.wearable.speedtracker/PhoneApplication.java Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright (C) 2014 Google Inc. All Rights Reserved.
*
* 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.example.android.wearable.speedtracker;
import android.app.Application;
import com.example.android.wearable.speedtracker.db.LocationDbHelper;
/**
* The {@link android.app.Application} class for the handset app.
*/
public class PhoneApplication extends Application {
private LocationDataManager mDataManager;
@Override
public void onCreate() {
super.onCreate();
LocationDbHelper dbHelper = new LocationDbHelper(getApplicationContext());
mDataManager = new LocationDataManager(dbHelper);
}
/**
* Returns an instance of {@link com.example.android.wearable.speedtracker.LocationDataManager}.
*/
public final LocationDataManager getDataManager() {
return mDataManager;
}
}

134
samples/browseable/SpeedTracker/Application/src/com.example.android.wearable.speedtracker/PhoneMainActivity.java Normal file
View File

@@ -0,0 +1,134 @@
/*
* Copyright (C) 2014 Google Inc. All Rights Reserved.
*
* 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.example.android.wearable.speedtracker;
import com.google.android.gms.maps.CameraUpdateFactory;
import com.google.android.gms.maps.GoogleMap;
import com.google.android.gms.maps.MapFragment;
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.LatLngBounds;
import com.google.android.gms.maps.model.PolylineOptions;
import android.app.Activity;
import android.app.DatePickerDialog;
import android.os.AsyncTask;
import android.os.Bundle;
import android.text.format.DateUtils;
import android.util.Log;
import android.view.View;
import android.widget.DatePicker;
import android.widget.TextView;
import com.example.android.wearable.speedtracker.common.LocationEntry;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
/**
* The main activity for the handset application. When a watch device reconnects to the handset
* app, the collected GPS data on the watch, if any, is synced up and user can see his/her track on
* a map. This data is then saved into an internal database and the corresponding data items are
* deleted.
*/
public class PhoneMainActivity extends Activity implements DatePickerDialog.OnDateSetListener {
private static final String TAG = "PhoneMainActivity";
private static final int BOUNDING_BOX_PADDING_PX = 50;
private TextView mSelectedDateText;
private GoogleMap mMap;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main_activity);
mSelectedDateText = (TextView) findViewById(R.id.selected_date);
mMap = ((MapFragment) getFragmentManager().findFragmentById(R.id.map)).getMap();
}
public void onClick(View view) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
new DatePickerDialog(PhoneMainActivity.this, PhoneMainActivity.this,
calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH)).show();
}
@Override
public void onDateSet(DatePicker view, int year, int monthOfYear, int dayOfMonth) {
// the following if-clause is to get around a bug that causes this callback to be called
// twice
if (view.isShown()) {
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.set(Calendar.YEAR, year);
calendar.set(Calendar.MONTH, monthOfYear);
calendar.set(Calendar.DAY_OF_MONTH, dayOfMonth);
String date = DateUtils.formatDateTime(this, calendar.getTimeInMillis(),
DateUtils.FORMAT_SHOW_DATE);
mSelectedDateText.setText(getString(R.string.showing_for_date, date));
showTrack(calendar);
}
}
/**
* An {@link android.os.AsyncTask} that is responsible for getting a list of {@link
* com.example.android.wearable.speedtracker.common.LocationEntry} objects for a given day and
* building a track from those points. In addition, it sets the smallest bounding box for the
* map that covers all the points on the track.
*/
private void showTrack(Calendar calendar) {
new AsyncTask<Calendar, Void, Void>() {
private List<LatLng> coordinates;
private LatLngBounds bounds;
@Override
protected Void doInBackground(Calendar... params) {
LocationDataManager dataManager = ((PhoneApplication) getApplicationContext())
.getDataManager();
List<LocationEntry> entries = dataManager.getPoints(params[0]);
if (entries != null && !entries.isEmpty()) {
coordinates = new ArrayList<LatLng>();
LatLngBounds.Builder builder = new LatLngBounds.Builder();
for (LocationEntry entry : entries) {
LatLng latLng = new LatLng(entry.latitude, entry.longitude);
builder.include(latLng);
coordinates.add(latLng);
}
bounds = builder.build();
}
return null;
}
@Override
protected void onPostExecute(Void aVoid) {
mMap.clear();
if (coordinates == null || coordinates.isEmpty()) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "No Entries found for that date");
}
} else {
mMap.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds,
BOUNDING_BOX_PADDING_PX));
mMap.addPolyline(new PolylineOptions().geodesic(true).addAll(coordinates));
}
}
}.execute(calendar);
}
}

165
samples/browseable/SpeedTracker/Application/src/com.example.android.wearable.speedtracker/db/LocationDbHelper.java Normal file
View File

@@ -0,0 +1,165 @@
/*
* Copyright (C) 2014 Google Inc. All Rights Reserved.
*
* 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.example.android.wearable.speedtracker.db;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.provider.BaseColumns;
import android.util.Log;
import com.example.android.wearable.speedtracker.common.LocationEntry;
import com.example.android.wearable.speedtracker.common.Utils;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
/**
* A helper class to set up the database that holds the GPS location information
*/
public class LocationDbHelper extends SQLiteOpenHelper {
private static final String TAG = "LocationDbHelper";
public static final String TABLE_NAME = "location";
public static final String COLUMN_NAME_DAY = "day";
public static final String COLUMN_NAME_LATITUDE = "lat";
public static final String COLUMN_NAME_LONGITUDE = "lon";
public static final String COLUMN_NAME_TIME = "time";
private static final String TEXT_TYPE = " TEXT";
private static final String INTEGER_TYPE = " INTEGER";
private static final String REAL_TYPE = " REAL";
private static final String COMMA_SEP = ",";
private static final String SQL_CREATE_ENTRIES =
"CREATE TABLE " + TABLE_NAME + " ("
+ BaseColumns._ID + " INTEGER PRIMARY KEY,"
+ COLUMN_NAME_DAY + TEXT_TYPE + COMMA_SEP
+ COLUMN_NAME_LATITUDE + REAL_TYPE + COMMA_SEP
+ COLUMN_NAME_LONGITUDE + REAL_TYPE + COMMA_SEP
+ COLUMN_NAME_TIME + INTEGER_TYPE
+ " )";
private static final String SQL_DELETE_ENTRIES = "DROP TABLE IF EXISTS " + TABLE_NAME;
public static final int DATABASE_VERSION = 1;
public static final String DATABASE_NAME = "Location.db";
public LocationDbHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(SQL_CREATE_ENTRIES);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL(SQL_DELETE_ENTRIES);
onCreate(db);
}
/**
* Inserts a {@link com.example.android.wearable.speedtracker.common.LocationEntry} item to the
* database.
*/
public final long insert(LocationEntry entry) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Inserting a LocationEntry");
}
// Gets the data repository in write mode
SQLiteDatabase db = getWritableDatabase();
// Create a new map of values, where column names are the keys
ContentValues values = new ContentValues();
values.put(COLUMN_NAME_DAY, entry.day);
values.put(COLUMN_NAME_LONGITUDE, entry.longitude);
values.put(COLUMN_NAME_LATITUDE, entry.latitude);
values.put(COLUMN_NAME_TIME, entry.calendar.getTimeInMillis());
// Insert the new row, returning the primary key value of the new row
return db.insert(TABLE_NAME, "null", values);
}
/**
* Returns a list of {@link com.example.android.wearable.speedtracker.common.LocationEntry}
* objects from the database for a given day. The list can be empty (but not {@code null}) if
* there are no such items. This method looks at the day that the calendar argument points at.
*/
public final List<LocationEntry> read(Calendar calendar) {
SQLiteDatabase db = getReadableDatabase();
String[] projection = {
COLUMN_NAME_LONGITUDE,
COLUMN_NAME_LATITUDE,
COLUMN_NAME_TIME
};
String day = Utils.getHashedDay(calendar);
// sort ASC based on the time of the entry
String sortOrder = COLUMN_NAME_TIME + " ASC";
String selection = COLUMN_NAME_DAY + " LIKE ?";
Cursor cursor = db.query(
TABLE_NAME, // The table to query
projection, // The columns to return
selection, // The columns for the WHERE clause
new String[]{day}, // The values for the WHERE clause
null, // don't group the rows
null, // don't filter by row groups
sortOrder // The sort order
);
List<LocationEntry> result = new ArrayList<LocationEntry>();
int count = cursor.getCount();
if (count > 0) {
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(cursor.getLong(2));
LocationEntry entry = new LocationEntry(cal, cursor.getDouble(1),
cursor.getDouble(0));
result.add(entry);
cursor.moveToNext();
}
}
cursor.close();
return result;
}
/**
* Deletes all the entries in the database for the given day. The argument {@code day} should
* match the format provided by {@link getHashedDay()}
*/
public final int delete(String day) {
SQLiteDatabase db = getWritableDatabase();
// Define 'where' part of the query.
String selection = COLUMN_NAME_DAY + " LIKE ?";
String[] selectionArgs = {day};
return db.delete(TABLE_NAME, selection, selectionArgs);
}
/**
* Deletes all the entries in the database for the day that the {@link java.util.Calendar}
* argument points at.
*/
public final int delete(Calendar calendar) {
return delete(Utils.getHashedDay(calendar));
}
}

135
samples/browseable/SpeedTracker/Application/src/com.example.android.wearable.speedtracker/db/UpdateService.java Normal file
View File

@@ -0,0 +1,135 @@
/*
* Copyright (C) 2014 Google Inc. All Rights Reserved.
*
* 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.example.android.wearable.speedtracker.db;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.wearable.DataApi;
import com.google.android.gms.wearable.DataEvent;
import com.google.android.gms.wearable.DataEventBuffer;
import com.google.android.gms.wearable.DataMap;
import com.google.android.gms.wearable.DataMapItem;
import com.google.android.gms.wearable.Wearable;
import com.google.android.gms.wearable.WearableListenerService;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import com.example.android.wearable.speedtracker.LocationDataManager;
import com.example.android.wearable.speedtracker.PhoneApplication;
import com.example.android.wearable.speedtracker.common.Constants;
import com.example.android.wearable.speedtracker.common.LocationEntry;
import java.util.Calendar;
import java.util.HashSet;
import java.util.Set;
/**
* A {@link com.google.android.gms.wearable.WearableListenerService} that is responsible for
* reading location data that gets added to the Data Layer storage.
*/
public class UpdateService extends WearableListenerService
implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener,
ResultCallback<DataApi.DeleteDataItemsResult> {
private static final String TAG = "UpdateService";
private LocationDataManager mDataManager;
private GoogleApiClient mGoogleApiClient;
private final Set<Uri> mToBeDeletedUris = new HashSet<Uri>();
public static final String ACTION_NOTIFY = "com.example.android.wearable.speedtracker.Message";
public static final String EXTRA_ENTRY = "entry";
public static final String EXTRA_LOG = "log";
@Override
public void onCreate() {
super.onCreate();
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addApi(Wearable.API)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.build();
mGoogleApiClient.connect();
mDataManager = ((PhoneApplication) getApplicationContext()).getDataManager();
}
@Override
public void onDataChanged(DataEventBuffer dataEvents) {
for (DataEvent dataEvent : dataEvents) {
if (dataEvent.getType() == DataEvent.TYPE_CHANGED) {
Uri dataItemUri = dataEvent.getDataItem().getUri();
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Received a data item with uri: " + dataItemUri.getPath());
}
if (dataItemUri.getPath().startsWith(Constants.PATH)) {
DataMap dataMap = DataMapItem.fromDataItem(dataEvent.getDataItem())
.getDataMap();
double longitude = dataMap.getDouble(Constants.KEY_LONGITUDE);
double latitude = dataMap.getDouble(Constants.KEY_LATITUDE);
long time = dataMap.getLong(Constants.KEY_TIME);
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(time);
mDataManager.addPoint(
new LocationEntry(calendar, latitude, longitude));
if (mGoogleApiClient.isConnected()) {
Wearable.DataApi.deleteDataItems(
mGoogleApiClient, dataItemUri).setResultCallback(this);
} else {
synchronized (mToBeDeletedUris) {
mToBeDeletedUris.add(dataItemUri);
}
}
}
}
}
}
@Override // ConnectionCallbacks
public void onConnected(Bundle bundle) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "onConnected(): api client is connected now");
}
synchronized (mToBeDeletedUris) {
if (!mToBeDeletedUris.isEmpty()) {
for (Uri dataItemUri : mToBeDeletedUris) {
Wearable.DataApi.deleteDataItems(
mGoogleApiClient, dataItemUri).setResultCallback(this);
}
}
}
}
@Override // ConnectionCallbacks
public void onConnectionSuspended(int i) {
}
@Override // OnConnectionFailedListener
public void onConnectionFailed(ConnectionResult connectionResult) {
Log.e(TAG, "Failed to connect to the Google API client");
}
@Override // ResultCallback
public void onResult(DataApi.DeleteDataItemsResult deleteDataItemsResult) {
if (!deleteDataItemsResult.getStatus().isSuccess()) {
Log.e(TAG,
"Failed to delete a dataItem, status code: " + deleteDataItemsResult.getStatus()
.getStatusCode() + deleteDataItemsResult.getStatus()
.getStatusMessage());
}
}
}