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/RecipeAssistant/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/RecipeAssistant/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/RecipeAssistant/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/RecipeAssistant/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/RecipeAssistant/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/RecipeAssistant/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/RecipeAssistant/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;
}
}

79
samples/browseable/RecipeAssistant/Application/src/com.example.android.recipeassistant/AssetUtils.java Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright (C) 2014 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.recipeassistant;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;
import java.io.InputStream;
final class AssetUtils {
private static final String TAG = "RecipeAssistant";
public static byte[] loadAsset(Context context, String asset) {
byte[] buffer = null;
try {
InputStream is = context.getAssets().open(asset);
int size = is.available();
buffer = new byte[size];
is.read(buffer);
is.close();
} catch (IOException e) {
Log.e(TAG, "Failed to load asset " + asset + ": " + e);
}
return buffer;
}
public static JSONObject loadJSONAsset(Context context, String asset) {
String jsonString = new String(loadAsset(context, asset));
JSONObject jsonObject = null;
try {
jsonObject = new JSONObject(jsonString);
} catch (JSONException e) {
Log.e(TAG, "Failed to parse JSON asset " + asset + ": " + e);
}
return jsonObject;
}
public static Bitmap loadBitmapAsset(Context context, String asset) {
InputStream is = null;
Bitmap bitmap = null;
try {
is = context.getAssets().open(asset);
if (is != null) {
bitmap = BitmapFactory.decodeStream(is);
}
} catch (IOException e) {
Log.e(TAG, e.toString());
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
Log.e(TAG, "Cannot close InputStream: ", e);
}
}
}
return bitmap;
}
}

43
samples/browseable/RecipeAssistant/Application/src/com.example.android.recipeassistant/Constants.java Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright (C) 2014 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.recipeassistant;
public final class Constants {
private Constants() {
}
public static final String RECIPE_LIST_FILE = "recipelist.json";
public static final String RECIPE_NAME_TO_LOAD = "recipe_name";
public static final String RECIPE_FIELD_LIST = "recipe_list";
public static final String RECIPE_FIELD_IMAGE = "img";
public static final String RECIPE_FIELD_INGREDIENTS = "ingredients";
public static final String RECIPE_FIELD_NAME = "name";
public static final String RECIPE_FIELD_SUMMARY = "summary";
public static final String RECIPE_FIELD_STEPS = "steps";
public static final String RECIPE_FIELD_TEXT = "text";
public static final String RECIPE_FIELD_TITLE = "title";
public static final String RECIPE_FIELD_STEP_TEXT = "step_text";
public static final String RECIPE_FIELD_STEP_IMAGE = "step_image";
static final String ACTION_START_COOKING =
"com.example.android.recipeassistant.START_COOKING";
public static final String EXTRA_RECIPE = "recipe";
public static final int NOTIFICATION_ID = 0;
public static final int NOTIFICATION_IMAGE_WIDTH = 280;
public static final int NOTIFICATION_IMAGE_HEIGHT = 280;
}

50
samples/browseable/RecipeAssistant/Application/src/com.example.android.recipeassistant/MainActivity.java Normal file
View File

@@ -0,0 +1,50 @@
/*
* Copyright (C) 2014 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.recipeassistant;
import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.ListView;
public class MainActivity extends ListActivity {
private static final String TAG = "RecipeAssistant";
private RecipeListAdapter mAdapter;
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG , "onListItemClick " + position);
}
String itemName = mAdapter.getItemName(position);
Intent intent = new Intent(getApplicationContext(), RecipeActivity.class);
intent.putExtra(Constants.RECIPE_NAME_TO_LOAD, itemName);
startActivity(intent);
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(android.R.layout.list_content);
mAdapter = new RecipeListAdapter(this);
setListAdapter(mAdapter);
}
}

126
samples/browseable/RecipeAssistant/Application/src/com.example.android.recipeassistant/Recipe.java Normal file
View File

@@ -0,0 +1,126 @@
/*
* Copyright (C) 2014 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.recipeassistant;
import android.content.Context;
import android.os.Bundle;
import android.os.Parcelable;
import android.util.Log;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
public class Recipe {
private static final String TAG = "RecipeAssistant";
public String titleText;
public String summaryText;
public String recipeImage;
public String ingredientsText;
public static class RecipeStep {
RecipeStep() { }
public String stepImage;
public String stepText;
public Bundle toBundle() {
Bundle bundle = new Bundle();
bundle.putString(Constants.RECIPE_FIELD_STEP_TEXT, stepText);
bundle.putString(Constants.RECIPE_FIELD_STEP_IMAGE, stepImage);
return bundle;
}
public static RecipeStep fromBundle(Bundle bundle) {
RecipeStep recipeStep = new RecipeStep();
recipeStep.stepText = bundle.getString(Constants.RECIPE_FIELD_STEP_TEXT);
recipeStep.stepImage = bundle.getString(Constants.RECIPE_FIELD_STEP_IMAGE);
return recipeStep;
}
}
ArrayList<RecipeStep> recipeSteps;
public Recipe() {
recipeSteps = new ArrayList<RecipeStep>();
}
public static Recipe fromJson(Context context, JSONObject json) {
Recipe recipe = new Recipe();
try {
recipe.titleText = json.getString(Constants.RECIPE_FIELD_TITLE);
recipe.summaryText = json.getString(Constants.RECIPE_FIELD_SUMMARY);
if (json.has(Constants.RECIPE_FIELD_IMAGE)) {
recipe.recipeImage = json.getString(Constants.RECIPE_FIELD_IMAGE);
}
JSONArray ingredients = json.getJSONArray(Constants.RECIPE_FIELD_INGREDIENTS);
recipe.ingredientsText = "";
for (int i = 0; i < ingredients.length(); i++) {
recipe.ingredientsText += " - "
+ ingredients.getJSONObject(i).getString(Constants.RECIPE_FIELD_TEXT) + "\n";
}
JSONArray steps = json.getJSONArray(Constants.RECIPE_FIELD_STEPS);
for (int i = 0; i < steps.length(); i++) {
JSONObject step = steps.getJSONObject(i);
RecipeStep recipeStep = new RecipeStep();
recipeStep.stepText = step.getString(Constants.RECIPE_FIELD_TEXT);
if (step.has(Constants.RECIPE_FIELD_IMAGE)) {
recipeStep.stepImage = step.getString(Constants.RECIPE_FIELD_IMAGE);
}
recipe.recipeSteps.add(recipeStep);
}
} catch (JSONException e) {
Log.e(TAG, "Error loading recipe: " + e);
return null;
}
return recipe;
}
public Bundle toBundle() {
Bundle bundle = new Bundle();
bundle.putString(Constants.RECIPE_FIELD_TITLE, titleText);
bundle.putString(Constants.RECIPE_FIELD_SUMMARY, summaryText);
bundle.putString(Constants.RECIPE_FIELD_IMAGE, recipeImage);
bundle.putString(Constants.RECIPE_FIELD_INGREDIENTS, ingredientsText);
if (recipeSteps != null) {
ArrayList<Parcelable> stepBundles = new ArrayList<Parcelable>(recipeSteps.size());
for (RecipeStep recipeStep : recipeSteps) {
stepBundles.add(recipeStep.toBundle());
}
bundle.putParcelableArrayList(Constants.RECIPE_FIELD_STEPS, stepBundles);
}
return bundle;
}
public static Recipe fromBundle(Bundle bundle) {
Recipe recipe = new Recipe();
recipe.titleText = bundle.getString(Constants.RECIPE_FIELD_TITLE);
recipe.summaryText = bundle.getString(Constants.RECIPE_FIELD_SUMMARY);
recipe.recipeImage = bundle.getString(Constants.RECIPE_FIELD_IMAGE);
recipe.ingredientsText = bundle.getString(Constants.RECIPE_FIELD_INGREDIENTS);
ArrayList<Parcelable> stepBundles =
bundle.getParcelableArrayList(Constants.RECIPE_FIELD_STEPS);
if (stepBundles != null) {
for (Parcelable stepBundle : stepBundles) {
recipe.recipeSteps.add(RecipeStep.fromBundle((Bundle) stepBundle));
}
}
return recipe;
}
}

138
samples/browseable/RecipeAssistant/Application/src/com.example.android.recipeassistant/RecipeActivity.java Normal file
View File

@@ -0,0 +1,138 @@
/*
* Copyright (C) 2014 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.recipeassistant;
import android.app.Activity;
import android.app.PendingIntent;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import org.json.JSONObject;
public class RecipeActivity extends Activity {
private static final String TAG = "RecipeAssistant";
private String mRecipeName;
private Recipe mRecipe;
private ImageView mImageView;
private TextView mTitleTextView;
private TextView mSummaryTextView;
private TextView mIngredientsTextView;
private LinearLayout mStepsLayout;
@Override
protected void onStart() {
super.onStart();
Intent intent = getIntent();
mRecipeName = intent.getStringExtra(Constants.RECIPE_NAME_TO_LOAD);
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Intent: " + intent.toString() + " " + mRecipeName);
}
loadRecipe();
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.recipe);
mTitleTextView = (TextView) findViewById(R.id.recipeTextTitle);
mSummaryTextView = (TextView) findViewById(R.id.recipeTextSummary);
mImageView = (ImageView) findViewById(R.id.recipeImageView);
mIngredientsTextView = (TextView) findViewById(R.id.textIngredients);
mStepsLayout = (LinearLayout) findViewById(R.id.layoutSteps);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch(item.getItemId()) {
case R.id.action_cook:
startCooking();
return true;
}
return super.onOptionsItemSelected(item);
}
private void loadRecipe() {
JSONObject jsonObject = AssetUtils.loadJSONAsset(this, mRecipeName);
if (jsonObject != null) {
mRecipe = Recipe.fromJson(this, jsonObject);
if (mRecipe != null) {
displayRecipe(mRecipe);
}
}
}
private void displayRecipe(Recipe recipe) {
Animation fadeIn = AnimationUtils.loadAnimation(this, android.R.anim.fade_in);
mTitleTextView.setAnimation(fadeIn);
mTitleTextView.setText(recipe.titleText);
mSummaryTextView.setText(recipe.summaryText);
if (recipe.recipeImage != null) {
mImageView.setAnimation(fadeIn);
Bitmap recipeImage = AssetUtils.loadBitmapAsset(this, recipe.recipeImage);
mImageView.setImageBitmap(recipeImage);
}
mIngredientsTextView.setText(recipe.ingredientsText);
findViewById(R.id.ingredientsHeader).setAnimation(fadeIn);
findViewById(R.id.ingredientsHeader).setVisibility(View.VISIBLE);
findViewById(R.id.stepsHeader).setAnimation(fadeIn);
findViewById(R.id.stepsHeader).setVisibility(View.VISIBLE);
LayoutInflater inf = LayoutInflater.from(this);
mStepsLayout.removeAllViews();
int stepNumber = 1;
for (Recipe.RecipeStep step : recipe.recipeSteps) {
View view = inf.inflate(R.layout.step_item, null);
ImageView iv = (ImageView) view.findViewById(R.id.stepImageView);
if (step.stepImage == null) {
iv.setVisibility(View.GONE);
} else {
Bitmap stepImage = AssetUtils.loadBitmapAsset(this, step.stepImage);
iv.setImageBitmap(stepImage);
}
((TextView) view.findViewById(R.id.textStep)).setText(
(stepNumber++) + ". " + step.stepText);
mStepsLayout.addView(view);
}
}
private void startCooking() {
Intent intent = new Intent(this, RecipeService.class);
intent.setAction(Constants.ACTION_START_COOKING);
intent.putExtra(Constants.EXTRA_RECIPE, mRecipe.toBundle());
startService(intent);
}
}

173
samples/browseable/RecipeAssistant/Application/src/com.example.android.recipeassistant/RecipeListAdapter.java Normal file
View File

@@ -0,0 +1,173 @@
/*
* Copyright (C) 2014 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.recipeassistant;
import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Bitmap;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.ListAdapter;
import android.widget.TextView;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.List;
public class RecipeListAdapter implements ListAdapter {
private String TAG = "RecipeListAdapter";
private class Item {
String title;
String name;
String summary;
Bitmap image;
}
private List<Item> mItems = new ArrayList<Item>();
private Context mContext;
private DataSetObserver mObserver;
public RecipeListAdapter(Context context) {
mContext = context;
loadRecipeList();
}
private void loadRecipeList() {
JSONObject jsonObject = AssetUtils.loadJSONAsset(mContext, Constants.RECIPE_LIST_FILE);
if (jsonObject != null) {
List<Item> items = parseJson(jsonObject);
appendItemsToList(items);
}
}
private List<Item> parseJson(JSONObject json) {
List<Item> result = new ArrayList<Item>();
try {
JSONArray items = json.getJSONArray(Constants.RECIPE_FIELD_LIST);
for (int i = 0; i < items.length(); i++) {
JSONObject item = items.getJSONObject(i);
Item parsed = new Item();
parsed.name = item.getString(Constants.RECIPE_FIELD_NAME);
parsed.title = item.getString(Constants.RECIPE_FIELD_TITLE);
if (item.has(Constants.RECIPE_FIELD_IMAGE)) {
String imageFile = item.getString(Constants.RECIPE_FIELD_IMAGE);
parsed.image = AssetUtils.loadBitmapAsset(mContext, imageFile);
}
parsed.summary = item.getString(Constants.RECIPE_FIELD_SUMMARY);
result.add(parsed);
}
} catch (JSONException e) {
Log.e(TAG, "Failed to parse recipe list: " + e);
}
return result;
}
private void appendItemsToList(List<Item> items) {
mItems.addAll(items);
if (mObserver != null) {
mObserver.onChanged();
}
}
@Override
public int getCount() {
return mItems.size();
}
@Override
public Object getItem(int position) {
return mItems.get(position);
}
@Override
public long getItemId(int position) {
return 0;
}
@Override
public int getItemViewType(int position) {
return 0;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
View view = convertView;
if (view == null) {
LayoutInflater inf = LayoutInflater.from(mContext);
view = inf.inflate(R.layout.list_item, null);
}
Item item = (Item) getItem(position);
TextView titleView = (TextView) view.findViewById(R.id.textTitle);
TextView summaryView = (TextView) view.findViewById(R.id.textSummary);
ImageView iv = (ImageView) view.findViewById(R.id.imageView);
titleView.setText(item.title);
summaryView.setText(item.summary);
if (item.image != null) {
iv.setImageBitmap(item.image);
} else {
iv.setImageDrawable(mContext.getResources().getDrawable(R.drawable.ic_noimage));
}
return view;
}
@Override
public int getViewTypeCount() {
return 1;
}
@Override
public boolean hasStableIds() {
return false;
}
@Override
public boolean isEmpty() {
return mItems.isEmpty();
}
@Override
public void registerDataSetObserver(DataSetObserver observer) {
mObserver = observer;
}
@Override
public void unregisterDataSetObserver(DataSetObserver observer) {
mObserver = null;
}
@Override
public boolean areAllItemsEnabled() {
return true;
}
@Override
public boolean isEnabled(int position) {
return true;
}
public String getItemName(int position) {
return mItems.get(position).name;
}
}

96
samples/browseable/RecipeAssistant/Application/src/com.example.android.recipeassistant/RecipeService.java Normal file
View File

@@ -0,0 +1,96 @@
/*
* Copyright (C) 2014 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.recipeassistant;
import android.app.Notification;
import android.app.Service;
import android.content.Intent;
import android.graphics.Bitmap;
import android.os.Binder;
import android.os.IBinder;
import android.support.v4.app.NotificationManagerCompat;
import android.support.v4.app.NotificationCompat;
import java.util.ArrayList;
public class RecipeService extends Service {
private NotificationManagerCompat mNotificationManager;
private Binder mBinder = new LocalBinder();
private Recipe mRecipe;
public class LocalBinder extends Binder {
RecipeService getService() {
return RecipeService.this;
}
}
@Override
public void onCreate() {
mNotificationManager = NotificationManagerCompat.from(this);
}
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
if (intent.getAction().equals(Constants.ACTION_START_COOKING)) {
createNotification(intent);
return START_STICKY;
}
return START_NOT_STICKY;
}
private void createNotification(Intent intent) {
mRecipe = Recipe.fromBundle(intent.getBundleExtra(Constants.EXTRA_RECIPE));
ArrayList<Notification> notificationPages = new ArrayList<Notification>();
int stepCount = mRecipe.recipeSteps.size();
for (int i = 0; i < stepCount; ++i) {
Recipe.RecipeStep recipeStep = mRecipe.recipeSteps.get(i);
NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle();
style.bigText(recipeStep.stepText);
style.setBigContentTitle(String.format(
getResources().getString(R.string.step_count), i + 1, stepCount));
style.setSummaryText("");
NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
builder.setStyle(style);
notificationPages.add(builder.build());
}
NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
if (mRecipe.recipeImage != null) {
Bitmap recipeImage = Bitmap.createScaledBitmap(
AssetUtils.loadBitmapAsset(this, mRecipe.recipeImage),
Constants.NOTIFICATION_IMAGE_WIDTH, Constants.NOTIFICATION_IMAGE_HEIGHT, false);
builder.setLargeIcon(recipeImage);
}
builder.setContentTitle(mRecipe.titleText);
builder.setContentText(mRecipe.summaryText);
builder.setSmallIcon(R.mipmap.ic_notification_recipe);
Notification notification = builder
.extend(new NotificationCompat.WearableExtender()
.addPages(notificationPages))
.build();
mNotificationManager.notify(Constants.NOTIFICATION_ID, notification);
}
}