From 1fb7c1d62ae2cec834941a6193e19014e8d63320 Mon Sep 17 00:00:00 2001 From: Riberto Junior Date: Tue, 6 Dec 2016 17:24:50 -0200 Subject: [PATCH] Initial commit --- .gitignore | 8 + app/.gitignore | 1 + app/build.gradle | 67 ++++++ app/proguard-butterknife-7.pro | 13 ++ app/proguard-google-play-services.pro | 19 ++ app/proguard-guava.pro | 31 +++ app/proguard-rules.pro | 26 +++ app/proguard-square-okhttp3.pro | 6 + app/proguard-square-okio.pro | 5 + app/proguard-support-v7-appcompat.pro | 7 + app/src/main/AndroidManifest.xml | 41 ++++ .../com/udacity/stockhawk/StockHawkApp.java | 18 ++ .../com/udacity/stockhawk/data/Contract.java | 56 ++++++ .../com/udacity/stockhawk/data/DbHelper.java | 43 ++++ .../com/udacity/stockhawk/data/PrefUtils.java | 91 +++++++++ .../udacity/stockhawk/data/StockProvider.java | 179 +++++++++++++++++ .../stockhawk/sync/QuoteIntentService.java | 20 ++ .../stockhawk/sync/QuoteJobService.java | 26 +++ .../udacity/stockhawk/sync/QuoteSyncJob.java | 168 ++++++++++++++++ .../udacity/stockhawk/ui/AddStockDialog.java | 69 +++++++ .../udacity/stockhawk/ui/MainActivity.java | 190 ++++++++++++++++++ .../udacity/stockhawk/ui/StockAdapter.java | 138 +++++++++++++ app/src/main/res/drawable-hdpi/ic_dollar.png | Bin 0 -> 912 bytes .../main/res/drawable-hdpi/ic_percentage.png | Bin 0 -> 1331 bytes app/src/main/res/drawable-mdpi/ic_dollar.png | Bin 0 -> 631 bytes .../main/res/drawable-mdpi/ic_percentage.png | Bin 0 -> 884 bytes .../drawable-nodpi/stocks_widget_preview.png | Bin 0 -> 48647 bytes app/src/main/res/drawable-xhdpi/ic_dollar.png | Bin 0 -> 1225 bytes .../main/res/drawable-xhdpi/ic_percentage.png | Bin 0 -> 1800 bytes .../main/res/drawable-xxhdpi/ic_dollar.png | Bin 0 -> 1969 bytes .../res/drawable-xxhdpi/ic_percentage.png | Bin 0 -> 2777 bytes .../main/res/drawable-xxxhdpi/ic_dollar.png | Bin 0 -> 2629 bytes .../res/drawable-xxxhdpi/ic_percentage.png | Bin 0 -> 3930 bytes app/src/main/res/drawable/fab_plus.xml | 9 + .../drawable/percent_change_pill_green.xml | 6 + .../res/drawable/percent_change_pill_red.xml | 6 + app/src/main/res/layout/activity_main.xml | 46 +++++ app/src/main/res/layout/add_stock_dialog.xml | 18 ++ app/src/main/res/layout/list_item_quote.xml | 43 ++++ .../main/res/menu/main_activity_settings.xml | 12 ++ app/src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 3418 bytes app/src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 2206 bytes app/src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 4842 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 7718 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 10486 bytes app/src/main/res/values/arrays.xml | 9 + app/src/main/res/values/colors.xml | 13 ++ app/src/main/res/values/dimens.xml | 4 + app/src/main/res/values/strings.xml | 39 ++++ app/src/main/res/values/styles.xml | 23 +++ build.gradle | 23 +++ gradle.properties | 18 ++ gradlew | 169 ++++++++++++++++ gradlew.bat | 84 ++++++++ settings.gradle | 1 + 55 files changed, 1745 insertions(+) create mode 100644 .gitignore create mode 100644 app/.gitignore create mode 100644 app/build.gradle create mode 100644 app/proguard-butterknife-7.pro create mode 100644 app/proguard-google-play-services.pro create mode 100644 app/proguard-guava.pro create mode 100644 app/proguard-rules.pro create mode 100644 app/proguard-square-okhttp3.pro create mode 100644 app/proguard-square-okio.pro create mode 100644 app/proguard-support-v7-appcompat.pro create mode 100644 app/src/main/AndroidManifest.xml create mode 100644 app/src/main/java/com/udacity/stockhawk/StockHawkApp.java create mode 100644 app/src/main/java/com/udacity/stockhawk/data/Contract.java create mode 100644 app/src/main/java/com/udacity/stockhawk/data/DbHelper.java create mode 100644 app/src/main/java/com/udacity/stockhawk/data/PrefUtils.java create mode 100644 app/src/main/java/com/udacity/stockhawk/data/StockProvider.java create mode 100644 app/src/main/java/com/udacity/stockhawk/sync/QuoteIntentService.java create mode 100644 app/src/main/java/com/udacity/stockhawk/sync/QuoteJobService.java create mode 100644 app/src/main/java/com/udacity/stockhawk/sync/QuoteSyncJob.java create mode 100644 app/src/main/java/com/udacity/stockhawk/ui/AddStockDialog.java create mode 100644 app/src/main/java/com/udacity/stockhawk/ui/MainActivity.java create mode 100644 app/src/main/java/com/udacity/stockhawk/ui/StockAdapter.java create mode 100644 app/src/main/res/drawable-hdpi/ic_dollar.png create mode 100644 app/src/main/res/drawable-hdpi/ic_percentage.png create mode 100644 app/src/main/res/drawable-mdpi/ic_dollar.png create mode 100644 app/src/main/res/drawable-mdpi/ic_percentage.png create mode 100644 app/src/main/res/drawable-nodpi/stocks_widget_preview.png create mode 100644 app/src/main/res/drawable-xhdpi/ic_dollar.png create mode 100644 app/src/main/res/drawable-xhdpi/ic_percentage.png create mode 100644 app/src/main/res/drawable-xxhdpi/ic_dollar.png create mode 100644 app/src/main/res/drawable-xxhdpi/ic_percentage.png create mode 100644 app/src/main/res/drawable-xxxhdpi/ic_dollar.png create mode 100644 app/src/main/res/drawable-xxxhdpi/ic_percentage.png create mode 100644 app/src/main/res/drawable/fab_plus.xml create mode 100644 app/src/main/res/drawable/percent_change_pill_green.xml create mode 100644 app/src/main/res/drawable/percent_change_pill_red.xml create mode 100644 app/src/main/res/layout/activity_main.xml create mode 100644 app/src/main/res/layout/add_stock_dialog.xml create mode 100644 app/src/main/res/layout/list_item_quote.xml create mode 100644 app/src/main/res/menu/main_activity_settings.xml create mode 100644 app/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 app/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 app/src/main/res/values/arrays.xml create mode 100644 app/src/main/res/values/colors.xml create mode 100644 app/src/main/res/values/dimens.xml create mode 100644 app/src/main/res/values/strings.xml create mode 100644 app/src/main/res/values/styles.xml create mode 100644 build.gradle create mode 100644 gradle.properties create mode 100644 gradlew create mode 100644 gradlew.bat create mode 100644 settings.gradle diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3830495 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +*.iml +.gradle +/local.properties +/.idea +.DS_Store +/build +/captures +/app/google-services.json diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..796b96d --- /dev/null +++ b/app/.gitignore @@ -0,0 +1 @@ +/build diff --git a/app/build.gradle b/app/build.gradle new file mode 100644 index 0000000..6d2780d --- /dev/null +++ b/app/build.gradle @@ -0,0 +1,67 @@ +apply plugin: 'com.android.application' +apply plugin: 'com.neenbedankt.android-apt' +apply plugin: 'com.noveogroup.android.check' + +repositories { + maven { url "https://jitpack.io" } +} + +android { + compileSdkVersion 25 + buildToolsVersion "25.0.0" + + defaultConfig { + applicationId "com.udacity.stockhawk" + minSdkVersion 21 + targetSdkVersion 25 + versionCode 1 + versionName "1.0" + multiDexEnabled true + } + + buildTypes { + + release { + minifyEnabled false + shrinkResources false + proguardFile "proguard-butterknife-7.pro" + proguardFile "proguard-google-play-services.pro" + proguardFile "proguard-guava.pro" + proguardFile "proguard-square-okhttp3.pro" + proguardFile "proguard-square-okio.pro" + proguardFile "proguard-support-v7-appcompat.pro" + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + + lintOptions { + warning 'InvalidPackage' + } +} + +check { + checkstyle { config hard() } + findbugs { config hard() } + pmd { + config hard() + skip true + } +} + +dependencies { + compile fileTree(dir: 'libs', include: ['*.jar']) + testCompile 'junit:junit:4.12' + compile 'com.android.support:appcompat-v7:25.0.0' + compile 'com.android.support:recyclerview-v7:25.0.0' + compile 'com.android.support:design:25.0.0' + compile 'com.jakewharton:butterknife:8.1.0' + apt 'com.jakewharton:butterknife-compiler:8.1.0' + compile 'com.google.guava:guava:19.0' + compile 'com.squareup.okio:okio:1.8.0' + compile 'com.squareup.okhttp3:okhttp:3.3.1' + compile 'com.yahoofinance-api:YahooFinanceAPI:3.3.0' + compile 'com.jakewharton.timber:timber:4.1.2' + compile 'com.melnykov:floatingactionbutton:1.3.0' + compile 'net.sf.opencsv:opencsv:2.3' + compile 'com.github.PhilJay:MPAndroidChart:v2.2.5' +} diff --git a/app/proguard-butterknife-7.pro b/app/proguard-butterknife-7.pro new file mode 100644 index 0000000..a04d9bc --- /dev/null +++ b/app/proguard-butterknife-7.pro @@ -0,0 +1,13 @@ +# ButterKnife 7 + +-keep class butterknife.** { *; } +-dontwarn butterknife.internal.** +-keep class **$$ViewBinder { *; } + +-keepclasseswithmembernames class * { + @butterknife.* ; +} + +-keepclasseswithmembernames class * { + @butterknife.* ; +} \ No newline at end of file diff --git a/app/proguard-google-play-services.pro b/app/proguard-google-play-services.pro new file mode 100644 index 0000000..ce55733 --- /dev/null +++ b/app/proguard-google-play-services.pro @@ -0,0 +1,19 @@ +## Google Play Services 4.3.23 specific rules ## +## https://developer.android.com/google/play-services/setup.html#Proguard ## + +-keep class * extends java.util.ListResourceBundle { + protected Object[][] getContents(); +} + +-keep public class com.google.android.gms.common.internal.safeparcel.SafeParcelable { + public static final *** NULL; +} + +-keepnames @com.google.android.gms.common.annotation.KeepName class * +-keepclassmembernames class * { + @com.google.android.gms.common.annotation.KeepName *; +} + +-keepnames class * implements android.os.Parcelable { + public static final ** CREATOR; +} diff --git a/app/proguard-guava.pro b/app/proguard-guava.pro new file mode 100644 index 0000000..898255b --- /dev/null +++ b/app/proguard-guava.pro @@ -0,0 +1,31 @@ +# Configuration for Guava 18.0 +# +# disagrees with instructions provided by Guava project: https://code.google.com/p/guava-libraries/wiki/UsingProGuardWithGuava + +-keep class com.google.common.io.Resources { + public static ; +} +-keep class com.google.common.collect.Lists { + public static ** reverse(**); +} +-keep class com.google.common.base.Charsets { + public static ; +} + +-keep class com.google.common.base.Joiner { + public static com.google.common.base.Joiner on(java.lang.String); + public ** join(...); +} + +-keep class com.google.common.collect.MapMakerInternalMap$ReferenceEntry +-keep class com.google.common.cache.LocalCache$ReferenceEntry + +# http://stackoverflow.com/questions/9120338/proguard-configuration-for-guava-with-obfuscation-and-optimization +-dontwarn javax.annotation.** +-dontwarn javax.inject.** +-dontwarn sun.misc.Unsafe + +# Guava 19.0 +-dontwarn java.lang.ClassValue +-dontwarn com.google.j2objc.annotations.Weak +-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro new file mode 100644 index 0000000..b29c183 --- /dev/null +++ b/app/proguard-rules.pro @@ -0,0 +1,26 @@ +# Add project specific ProGuard rules here. +# By default, the flags in this file are appended to flags specified +# in /Users/silver/Library/Android/sdk/tools/proguard/proguard-android.txt +# You can edit the include path and order by changing the proguardFiles +# directive in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# Add any project specific keep options here: + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + + +-assumenosideeffects class java.util.logging.Logger { + public *** log(...); +} + +-keep class com.github.mikephil.charting.** { *; } + +-dontwarn io.realm.** diff --git a/app/proguard-square-okhttp3.pro b/app/proguard-square-okhttp3.pro new file mode 100644 index 0000000..64e6852 --- /dev/null +++ b/app/proguard-square-okhttp3.pro @@ -0,0 +1,6 @@ +# OkHttp +-keepattributes Signature +-keepattributes *Annotation* +-keep class okhttp3.** { *; } +-keep interface okhttp3.** { *; } +-dontwarn okhttp3.** \ No newline at end of file diff --git a/app/proguard-square-okio.pro b/app/proguard-square-okio.pro new file mode 100644 index 0000000..589e679 --- /dev/null +++ b/app/proguard-square-okio.pro @@ -0,0 +1,5 @@ +# Okio +-keep class sun.misc.Unsafe { *; } +-dontwarn java.nio.file.* +-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement +-dontwarn okio.** \ No newline at end of file diff --git a/app/proguard-support-v7-appcompat.pro b/app/proguard-support-v7-appcompat.pro new file mode 100644 index 0000000..65068d0 --- /dev/null +++ b/app/proguard-support-v7-appcompat.pro @@ -0,0 +1,7 @@ +-keep public class android.support.v7.widget.** { *; } +-keep public class android.support.v7.internal.widget.** { *; } +-keep public class android.support.v7.internal.view.menu.** { *; } + +-keep public class * extends android.support.v4.view.ActionProvider { + public (android.content.Context); +} diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..1d2192d --- /dev/null +++ b/app/src/main/AndroidManifest.xml @@ -0,0 +1,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/src/main/java/com/udacity/stockhawk/StockHawkApp.java b/app/src/main/java/com/udacity/stockhawk/StockHawkApp.java new file mode 100644 index 0000000..8218e56 --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/StockHawkApp.java @@ -0,0 +1,18 @@ +package com.udacity.stockhawk; + +import android.app.Application; + +import timber.log.Timber; + +public class StockHawkApp extends Application { + + @Override + public void onCreate() { + super.onCreate(); + + if (BuildConfig.DEBUG) { + Timber.uprootAll(); + Timber.plant(new Timber.DebugTree()); + } + } +} diff --git a/app/src/main/java/com/udacity/stockhawk/data/Contract.java b/app/src/main/java/com/udacity/stockhawk/data/Contract.java new file mode 100644 index 0000000..c6402bf --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/data/Contract.java @@ -0,0 +1,56 @@ +package com.udacity.stockhawk.data; + + +import android.net.Uri; +import android.provider.BaseColumns; + +public class Contract { + + public static final String AUTHORITY = "com.udacity.stockhawk"; + + public static final Uri BASE_URI = Uri.parse("content://" + AUTHORITY); + + public static final String PATH_QUOTE = "quote"; + public static final String PATH_QUOTE_WITH_SYMBOL = "quote/*"; + + public static final class Quote implements BaseColumns { + + public static final Uri uri = BASE_URI.buildUpon().appendPath(PATH_QUOTE).build(); + + public static final String TABLE_NAME = "quotes"; + + public static final String COLUMN_SYMBOL = "symbol"; + public static final String COLUMN_PRICE = "price"; + public static final String COLUMN_ABSOLUTE_CHANGE = "absolute_change"; + public static final String COLUMN_PERCENTAGE_CHANGE = "percentage_change"; + public static final String COLUMN_HISTORY = "history"; + + + public static final int POSITION_ID = 0; + public static final int POSITION_SYMBOL = 1; + public static final int POSITION_PRICE = 2; + public static final int POSITION_ABSOLUTE_CHANGE = 3; + public static final int POSITION_PERCENTAGE_CHANGE = 4; + public static final int POSITION_HISTORY = 5; + + public static final String[] QUOTE_COLUMNS = { + _ID, + COLUMN_SYMBOL, + COLUMN_PRICE, + COLUMN_ABSOLUTE_CHANGE, + COLUMN_PERCENTAGE_CHANGE, + COLUMN_HISTORY + }; + + public static Uri makeUriForStock(String symbol) { + return uri.buildUpon().appendPath(symbol).build(); + } + + public static String getStockFromUri(Uri uri) { + return uri.getLastPathSegment(); + } + + + } + +} diff --git a/app/src/main/java/com/udacity/stockhawk/data/DbHelper.java b/app/src/main/java/com/udacity/stockhawk/data/DbHelper.java new file mode 100644 index 0000000..522798a --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/data/DbHelper.java @@ -0,0 +1,43 @@ +package com.udacity.stockhawk.data; + +import android.content.Context; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteOpenHelper; + +import com.udacity.stockhawk.data.Contract.Quote; + + +public class DbHelper extends SQLiteOpenHelper { + + + static final String NAME = "StockHawk.db"; + private static final int VERSION = 1; + + + public DbHelper(Context context) { + super(context, NAME, null, VERSION); + } + + @Override + public void onCreate(SQLiteDatabase db) { + String builder = "CREATE TABLE " + Quote.TABLE_NAME + " (" + + Quote._ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + + Quote.COLUMN_SYMBOL + " TEXT NOT NULL, " + + Quote.COLUMN_PRICE + " REAL NOT NULL, " + + Quote.COLUMN_ABSOLUTE_CHANGE + " REAL NOT NULL, " + + Quote.COLUMN_PERCENTAGE_CHANGE + " REAL NOT NULL, " + + Quote.COLUMN_HISTORY + " TEXT NOT NULL, " + + "UNIQUE (" + Quote.COLUMN_SYMBOL + ") ON CONFLICT REPLACE);"; + + db.execSQL(builder); + + } + + @Override + public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + + db.execSQL(" DROP TABLE IF EXISTS " + Quote.TABLE_NAME); + + onCreate(db); + } +} diff --git a/app/src/main/java/com/udacity/stockhawk/data/PrefUtils.java b/app/src/main/java/com/udacity/stockhawk/data/PrefUtils.java new file mode 100644 index 0000000..6fc8e9a --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/data/PrefUtils.java @@ -0,0 +1,91 @@ +package com.udacity.stockhawk.data; + +import android.content.Context; +import android.content.SharedPreferences; +import android.preference.PreferenceManager; + +import com.udacity.stockhawk.R; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +public final class PrefUtils { + + private PrefUtils() { + } + + public static Set getStocks(Context context) { + String stocksKey = context.getString(R.string.pref_stocks_key); + String initializedKey = context.getString(R.string.pref_stocks_initialized_key); + String[] defaultStocksList = context.getResources().getStringArray(R.array.default_stocks); + + HashSet defaultStocks = new HashSet<>(Arrays.asList(defaultStocksList)); + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + + + boolean initialized = prefs.getBoolean(initializedKey, false); + + if (!initialized) { + SharedPreferences.Editor editor = prefs.edit(); + editor.putBoolean(initializedKey, true); + editor.putStringSet(stocksKey, defaultStocks); + editor.apply(); + return defaultStocks; + } + return prefs.getStringSet(stocksKey, new HashSet()); + + } + + public static void editStockPref(Context context, String symbol, Boolean add) { + String key = context.getString(R.string.pref_stocks_key); + Set stocks = getStocks(context); + + if (add) { + stocks.add(symbol); + } else { + stocks.remove(symbol); + } + + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + SharedPreferences.Editor editor = prefs.edit(); + editor.putStringSet(key, stocks); + editor.apply(); + } + + public static void addStock(Context context, String symbol) { + editStockPref(context, symbol, true); + } + + public static void removeStock(Context context, String symbol) { + editStockPref(context, symbol, false); + } + + public static String getDisplayMode(Context context) { + String key = context.getString(R.string.pref_display_mode_key); + String defaultValue = context.getString(R.string.pref_display_mode_default); + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + return prefs.getString(key, defaultValue); + } + + public static void toggleDisplayMode(Context context) { + String key = context.getString(R.string.pref_display_mode_key); + String absoluteKey = context.getString(R.string.pref_display_mode_absolute_key); + String percentageKey = context.getString(R.string.pref_display_mode_percentage_key); + + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + + String displayMode = getDisplayMode(context); + + SharedPreferences.Editor editor = prefs.edit(); + + if (displayMode.equals(absoluteKey)) { + editor.putString(key, percentageKey); + } else { + editor.putString(key, absoluteKey); + } + + editor.apply(); + } + +} diff --git a/app/src/main/java/com/udacity/stockhawk/data/StockProvider.java b/app/src/main/java/com/udacity/stockhawk/data/StockProvider.java new file mode 100644 index 0000000..8060d12 --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/data/StockProvider.java @@ -0,0 +1,179 @@ +package com.udacity.stockhawk.data; + +import android.content.ContentProvider; +import android.content.ContentValues; +import android.content.UriMatcher; +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; +import android.net.Uri; +import android.support.annotation.NonNull; +import android.support.annotation.Nullable; + + +public class StockProvider extends ContentProvider { + + static final int QUOTE = 100; + static final int QUOTE_FOR_SYMBOL = 101; + + static UriMatcher uriMatcher = buildUriMatcher(); + + private DbHelper dbHelper; + + static UriMatcher buildUriMatcher() { + UriMatcher matcher = new UriMatcher(UriMatcher.NO_MATCH); + matcher.addURI(Contract.AUTHORITY, Contract.PATH_QUOTE, QUOTE); + matcher.addURI(Contract.AUTHORITY, Contract.PATH_QUOTE_WITH_SYMBOL, QUOTE_FOR_SYMBOL); + return matcher; + } + + + @Override + public boolean onCreate() { + dbHelper = new DbHelper(getContext()); + return true; + } + + @Nullable + @Override + public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) { + Cursor returnCursor; + SQLiteDatabase db = dbHelper.getReadableDatabase(); + + switch (uriMatcher.match(uri)) { + case QUOTE: + returnCursor = db.query( + Contract.Quote.TABLE_NAME, + projection, + selection, + selectionArgs, + null, + null, + sortOrder + ); + break; + + case QUOTE_FOR_SYMBOL: + returnCursor = db.query( + Contract.Quote.TABLE_NAME, + projection, + Contract.Quote.COLUMN_SYMBOL + " = ?", + new String[]{Contract.Quote.getStockFromUri(uri)}, + null, + null, + sortOrder + ); + + break; + default: + throw new UnsupportedOperationException("Unknown URI:" + uri); + } + + returnCursor.setNotificationUri(getContext().getContentResolver(), uri); + +// if (db.isOpen()) { +// db.close(); +// } + + return returnCursor; + } + + @Nullable + @Override + public String getType(Uri uri) { + return null; + } + + @Nullable + @Override + public Uri insert(@NonNull Uri uri, ContentValues values) { + SQLiteDatabase db = dbHelper.getWritableDatabase(); + Uri returnUri; + + switch (uriMatcher.match(uri)) { + case QUOTE: + db.insert( + Contract.Quote.TABLE_NAME, + null, + values + ); + returnUri = Contract.Quote.uri; + break; + default: + throw new UnsupportedOperationException("Unknown URI:" + uri); + } + + getContext().getContentResolver().notifyChange(uri, null); + + + return returnUri; + } + + @Override + public int delete(Uri uri, String selection, String[] selectionArgs) { + final SQLiteDatabase db = dbHelper.getWritableDatabase(); + int rowsDeleted; + + if (null == selection) selection = "1"; + switch (uriMatcher.match(uri)) { + case QUOTE: + rowsDeleted = db.delete( + Contract.Quote.TABLE_NAME, + selection, + selectionArgs + ); + + break; + + case QUOTE_FOR_SYMBOL: + String symbol = Contract.Quote.getStockFromUri(uri); + rowsDeleted = db.delete( + Contract.Quote.TABLE_NAME, + '"' + symbol + '"' + " =" + Contract.Quote.COLUMN_SYMBOL, + selectionArgs + ); + break; + default: + throw new UnsupportedOperationException("Unknown URI:" + uri); + } + + if (rowsDeleted != 0) { + getContext().getContentResolver().notifyChange(uri, null); + } + return rowsDeleted; + } + + @Override + public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) { + return 0; + } + + @Override + public int bulkInsert(Uri uri, ContentValues[] values) { + + final SQLiteDatabase db = dbHelper.getWritableDatabase(); + + switch (uriMatcher.match(uri)) { + case QUOTE: + db.beginTransaction(); + int returnCount = 0; + try { + for (ContentValues value : values) { + db.insert( + Contract.Quote.TABLE_NAME, + null, + value + ); + } + db.setTransactionSuccessful(); + } finally { + db.endTransaction(); + } + getContext().getContentResolver().notifyChange(uri, null); + return returnCount; + default: + return super.bulkInsert(uri, values); + } + + + } +} diff --git a/app/src/main/java/com/udacity/stockhawk/sync/QuoteIntentService.java b/app/src/main/java/com/udacity/stockhawk/sync/QuoteIntentService.java new file mode 100644 index 0000000..42bea9b --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/sync/QuoteIntentService.java @@ -0,0 +1,20 @@ +package com.udacity.stockhawk.sync; + +import android.app.IntentService; +import android.content.Intent; + +import timber.log.Timber; + + +public class QuoteIntentService extends IntentService { + + public QuoteIntentService() { + super(QuoteIntentService.class.getSimpleName()); + } + + @Override + protected void onHandleIntent(Intent intent) { + Timber.d("Intent handled"); + QuoteSyncJob.getQuotes(getApplicationContext()); + } +} diff --git a/app/src/main/java/com/udacity/stockhawk/sync/QuoteJobService.java b/app/src/main/java/com/udacity/stockhawk/sync/QuoteJobService.java new file mode 100644 index 0000000..7b06cf1 --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/sync/QuoteJobService.java @@ -0,0 +1,26 @@ +package com.udacity.stockhawk.sync; + +import android.app.job.JobParameters; +import android.app.job.JobService; +import android.content.Intent; + +import timber.log.Timber; + +public class QuoteJobService extends JobService { + + + @Override + public boolean onStartJob(JobParameters jobParameters) { + Timber.d("Intent handled"); + Intent nowIntent = new Intent(getApplicationContext(), QuoteIntentService.class); + getApplicationContext().startService(nowIntent); + return true; + } + + @Override + public boolean onStopJob(JobParameters jobParameters) { + return false; + } + + +} diff --git a/app/src/main/java/com/udacity/stockhawk/sync/QuoteSyncJob.java b/app/src/main/java/com/udacity/stockhawk/sync/QuoteSyncJob.java new file mode 100644 index 0000000..c6a3725 --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/sync/QuoteSyncJob.java @@ -0,0 +1,168 @@ +package com.udacity.stockhawk.sync; + +import android.app.job.JobInfo; +import android.app.job.JobScheduler; +import android.content.ComponentName; +import android.content.ContentValues; +import android.content.Context; +import android.content.Intent; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; + +import com.udacity.stockhawk.data.Contract; +import com.udacity.stockhawk.data.PrefUtils; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import timber.log.Timber; +import yahoofinance.Stock; +import yahoofinance.YahooFinance; +import yahoofinance.histquotes.HistoricalQuote; +import yahoofinance.histquotes.Interval; +import yahoofinance.quotes.stock.StockQuote; + +public final class QuoteSyncJob { + + static final int ONE_OFF_ID = 2; + private static final String ACTION_DATA_UPDATED = "com.udacity.stockhawk.ACTION_DATA_UPDATED"; + private static final int PERIOD = 300000; + private static final int INITIAL_BACKOFF = 10000; + private static final int PERIODIC_ID = 1; + + static void getQuotes(Context context) { + + Timber.d("Running sync job"); + + Calendar from = Calendar.getInstance(); + Calendar to = Calendar.getInstance(); + from.add(Calendar.YEAR, -2); + + try { + + Set stockPref = PrefUtils.getStocks(context); + Set stockCopy = new HashSet<>(); + stockCopy.addAll(stockPref); + String[] stockArray = stockPref.toArray(new String[stockPref.size()]); + + Timber.d(stockCopy.toString()); + + if (stockArray.length == 0) { + return; + } + + Map quotes = YahooFinance.get(stockArray); + Iterator iterator = stockCopy.iterator(); + + Timber.d(quotes.toString()); + + ArrayList quoteCVs = new ArrayList<>(); + + while (iterator.hasNext()) { + String symbol = iterator.next(); + + + Stock stock = quotes.get(symbol); + StockQuote quote = stock.getQuote(); + + float price = quote.getPrice().floatValue(); + float change = quote.getChange().floatValue(); + float percentChange = quote.getChangeInPercent().floatValue(); + + // WARNING! Don't request historical data for a stock that doesn't exist! + // The request will hang forever X_x + List history = stock.getHistory(from, to, Interval.WEEKLY); + + StringBuilder historyBuilder = new StringBuilder(); + + for (HistoricalQuote it : history) { + historyBuilder.append(it.getDate().getTimeInMillis()); + historyBuilder.append(", "); + historyBuilder.append(it.getClose()); + historyBuilder.append("\n"); + } + + ContentValues quoteCV = new ContentValues(); + quoteCV.put(Contract.Quote.COLUMN_SYMBOL, symbol); + quoteCV.put(Contract.Quote.COLUMN_PRICE, price); + quoteCV.put(Contract.Quote.COLUMN_PERCENTAGE_CHANGE, percentChange); + quoteCV.put(Contract.Quote.COLUMN_ABSOLUTE_CHANGE, change); + + + quoteCV.put(Contract.Quote.COLUMN_HISTORY, historyBuilder.toString()); + + quoteCVs.add(quoteCV); + + } + + context.getContentResolver() + .bulkInsert( + Contract.Quote.uri, + quoteCVs.toArray(new ContentValues[quoteCVs.size()])); + + Intent dataUpdatedIntent = new Intent(ACTION_DATA_UPDATED); + context.sendBroadcast(dataUpdatedIntent); + + } catch (IOException exception) { + Timber.e(exception, "Error fetching stock quotes"); + } + } + + private static void schedulePeriodic(Context context) { + Timber.d("Scheduling a periodic task"); + + + JobInfo.Builder builder = new JobInfo.Builder(PERIODIC_ID, new ComponentName(context, QuoteJobService.class)); + + + builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) + .setPeriodic(PERIOD) + .setBackoffCriteria(INITIAL_BACKOFF, JobInfo.BACKOFF_POLICY_EXPONENTIAL); + + + JobScheduler scheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE); + + scheduler.schedule(builder.build()); + } + + + synchronized public static void initialize(final Context context) { + + schedulePeriodic(context); + syncImmediately(context); + + } + + synchronized public static void syncImmediately(Context context) { + + ConnectivityManager cm = + (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); + NetworkInfo networkInfo = cm.getActiveNetworkInfo(); + if (networkInfo != null && networkInfo.isConnectedOrConnecting()) { + Intent nowIntent = new Intent(context, QuoteIntentService.class); + context.startService(nowIntent); + } else { + + JobInfo.Builder builder = new JobInfo.Builder(ONE_OFF_ID, new ComponentName(context, QuoteJobService.class)); + + + builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) + .setBackoffCriteria(INITIAL_BACKOFF, JobInfo.BACKOFF_POLICY_EXPONENTIAL); + + + JobScheduler scheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE); + + scheduler.schedule(builder.build()); + + + } + } + + +} diff --git a/app/src/main/java/com/udacity/stockhawk/ui/AddStockDialog.java b/app/src/main/java/com/udacity/stockhawk/ui/AddStockDialog.java new file mode 100644 index 0000000..eaf0c29 --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/ui/AddStockDialog.java @@ -0,0 +1,69 @@ +package com.udacity.stockhawk.ui; + +import android.app.Activity; +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.DialogFragment; +import android.content.DialogInterface; +import android.os.Bundle; +import android.view.KeyEvent; +import android.view.LayoutInflater; +import android.view.View; +import android.view.WindowManager; +import android.widget.EditText; +import android.widget.TextView; + +import com.udacity.stockhawk.R; + +import butterknife.BindView; +import butterknife.ButterKnife; + + +public class AddStockDialog extends DialogFragment { + + @BindView(R.id.dialog_stock) + EditText stock; + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + + AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); + + LayoutInflater inflater = LayoutInflater.from(getActivity()); + View custom = inflater.inflate(R.layout.add_stock_dialog, null); + + ButterKnife.bind(this, custom); + + stock.setOnEditorActionListener(new TextView.OnEditorActionListener() { + @Override + public boolean onEditorAction(TextView v, int actionId, KeyEvent event) { + addStock(); + return true; + } + }); + builder.setView(custom); + + builder.setMessage(getString(R.string.dialog_title)); + builder.setPositiveButton(getString(R.string.dialog_add), + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int id) { + addStock(); + } + }); + builder.setNegativeButton(getString(R.string.dialog_cancel), null); + + Dialog dialog = builder.create(); + dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); + return dialog; + } + + private void addStock() { + Activity parent = getActivity(); + if (parent instanceof MainActivity) { + ((MainActivity) parent).addStock(stock.getText().toString()); + } + dismissAllowingStateLoss(); + } + + +} diff --git a/app/src/main/java/com/udacity/stockhawk/ui/MainActivity.java b/app/src/main/java/com/udacity/stockhawk/ui/MainActivity.java new file mode 100644 index 0000000..3a53096 --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/ui/MainActivity.java @@ -0,0 +1,190 @@ +package com.udacity.stockhawk.ui; + +import android.content.Context; +import android.database.Cursor; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.os.Bundle; +import android.support.design.widget.FloatingActionButton; +import android.support.v4.app.LoaderManager; +import android.support.v4.content.CursorLoader; +import android.support.v4.content.Loader; +import android.support.v4.widget.SwipeRefreshLayout; +import android.support.v7.app.AppCompatActivity; +import android.support.v7.widget.LinearLayoutManager; +import android.support.v7.widget.RecyclerView; +import android.support.v7.widget.helper.ItemTouchHelper; +import android.view.Menu; +import android.view.MenuItem; +import android.view.View; +import android.widget.TextView; +import android.widget.Toast; + +import com.udacity.stockhawk.R; +import com.udacity.stockhawk.data.Contract; +import com.udacity.stockhawk.data.PrefUtils; +import com.udacity.stockhawk.sync.QuoteSyncJob; + +import butterknife.BindView; +import butterknife.ButterKnife; +import timber.log.Timber; + +public class MainActivity extends AppCompatActivity implements LoaderManager.LoaderCallbacks, + SwipeRefreshLayout.OnRefreshListener, + StockAdapter.StockAdapterOnClickHandler { + + private static final int STOCK_LOADER = 0; + @BindView(R.id.recycler_view) + RecyclerView recyclerView; + @BindView(R.id.fab) + FloatingActionButton fab; + @BindView(R.id.swipe_refresh) + SwipeRefreshLayout swipeRefreshLayout; + @BindView(R.id.error) + TextView error; + private StockAdapter adapter; + + @Override + public void onClick(String symbol) { + Timber.d("Symbol clicked: %s", symbol); + } + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + setContentView(R.layout.activity_main); + ButterKnife.bind(this); + + adapter = new StockAdapter(this, this); + recyclerView.setAdapter(adapter); + recyclerView.setLayoutManager(new LinearLayoutManager(this)); + + swipeRefreshLayout.setOnRefreshListener(this); + swipeRefreshLayout.setRefreshing(true); + onRefresh(); + + QuoteSyncJob.initialize(this); + getSupportLoaderManager().initLoader(STOCK_LOADER, null, this); + + new ItemTouchHelper(new ItemTouchHelper.SimpleCallback(0, ItemTouchHelper.RIGHT) { + @Override + public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder, RecyclerView.ViewHolder target) { + return false; + } + + @Override + public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) { + String symbol = adapter.getSymbolAtPosition(viewHolder.getAdapterPosition()); + PrefUtils.removeStock(MainActivity.this, symbol); + getContentResolver().delete(Contract.Quote.makeUriForStock(symbol), null, null); + } + }).attachToRecyclerView(recyclerView); + + + } + + private boolean networkUp() { + ConnectivityManager cm = + (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); + NetworkInfo networkInfo = cm.getActiveNetworkInfo(); + return networkInfo != null && networkInfo.isConnectedOrConnecting(); + } + + @Override + public void onRefresh() { + + QuoteSyncJob.syncImmediately(this); + + if (!networkUp() && adapter.getItemCount() == 0) { + swipeRefreshLayout.setRefreshing(false); + error.setText(getString(R.string.error_no_network)); + error.setVisibility(View.VISIBLE); + } else if (!networkUp()) { + swipeRefreshLayout.setRefreshing(false); + Toast.makeText(this, R.string.toast_no_connectivity, Toast.LENGTH_LONG).show(); + } else if (PrefUtils.getStocks(this).size() == 0) { + Timber.d("WHYAREWEHERE"); + swipeRefreshLayout.setRefreshing(false); + error.setText(getString(R.string.error_no_stocks)); + error.setVisibility(View.VISIBLE); + } else { + error.setVisibility(View.GONE); + } + } + + public void button(View view) { + new AddStockDialog().show(getFragmentManager(), "StockDialogFragment"); + } + + void addStock(String symbol) { + if (symbol != null && !symbol.isEmpty()) { + + if (networkUp()) { + swipeRefreshLayout.setRefreshing(true); + } else { + String message = getString(R.string.toast_stock_added_no_connectivity, symbol); + Toast.makeText(this, message, Toast.LENGTH_LONG).show(); + } + + PrefUtils.addStock(this, symbol); + QuoteSyncJob.syncImmediately(this); + } + } + + @Override + public Loader onCreateLoader(int id, Bundle args) { + return new CursorLoader(this, + Contract.Quote.uri, + Contract.Quote.QUOTE_COLUMNS, + null, null, Contract.Quote.COLUMN_SYMBOL); + } + + @Override + public void onLoadFinished(Loader loader, Cursor data) { + swipeRefreshLayout.setRefreshing(false); + + if (data.getCount() != 0) { + error.setVisibility(View.GONE); + } + adapter.setCursor(data); + } + + + @Override + public void onLoaderReset(Loader loader) { + swipeRefreshLayout.setRefreshing(false); + adapter.setCursor(null); + } + + + private void setDisplayModeMenuItemIcon(MenuItem item) { + if (PrefUtils.getDisplayMode(this) + .equals(getString(R.string.pref_display_mode_absolute_key))) { + item.setIcon(R.drawable.ic_percentage); + } else { + item.setIcon(R.drawable.ic_dollar); + } + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { + getMenuInflater().inflate(R.menu.main_activity_settings, menu); + MenuItem item = menu.findItem(R.id.action_change_units); + setDisplayModeMenuItemIcon(item); + return true; + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + int id = item.getItemId(); + + if (id == R.id.action_change_units) { + PrefUtils.toggleDisplayMode(this); + setDisplayModeMenuItemIcon(item); + adapter.notifyDataSetChanged(); + return true; + } + return super.onOptionsItemSelected(item); + } +} diff --git a/app/src/main/java/com/udacity/stockhawk/ui/StockAdapter.java b/app/src/main/java/com/udacity/stockhawk/ui/StockAdapter.java new file mode 100644 index 0000000..75a916e --- /dev/null +++ b/app/src/main/java/com/udacity/stockhawk/ui/StockAdapter.java @@ -0,0 +1,138 @@ +package com.udacity.stockhawk.ui; + + +import android.content.Context; +import android.database.Cursor; +import android.support.v7.widget.RecyclerView; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import com.udacity.stockhawk.R; +import com.udacity.stockhawk.data.Contract; +import com.udacity.stockhawk.data.PrefUtils; + +import java.text.DecimalFormat; +import java.text.NumberFormat; +import java.util.Locale; + +import butterknife.BindView; +import butterknife.ButterKnife; + +class StockAdapter extends RecyclerView.Adapter { + + final private Context context; + final private DecimalFormat dollarFormatWithPlus; + final private DecimalFormat dollarFormat; + final private DecimalFormat percentageFormat; + private Cursor cursor; + private StockAdapterOnClickHandler clickHandler; + + StockAdapter(Context context, StockAdapterOnClickHandler clickHandler) { + this.context = context; + this.clickHandler = clickHandler; + + dollarFormat = (DecimalFormat) NumberFormat.getCurrencyInstance(Locale.US); + dollarFormatWithPlus = (DecimalFormat) NumberFormat.getCurrencyInstance(Locale.US); + dollarFormatWithPlus.setPositivePrefix("+$"); + percentageFormat = (DecimalFormat) NumberFormat.getPercentInstance(Locale.getDefault()); + percentageFormat.setMaximumFractionDigits(2); + percentageFormat.setMinimumFractionDigits(2); + percentageFormat.setPositivePrefix("+"); + } + + void setCursor(Cursor cursor) { + this.cursor = cursor; + notifyDataSetChanged(); + } + + String getSymbolAtPosition(int position) { + + cursor.moveToPosition(position); + return cursor.getString(Contract.Quote.POSITION_SYMBOL); + } + + @Override + public StockViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { + + View item = LayoutInflater.from(context).inflate(R.layout.list_item_quote, parent, false); + + return new StockViewHolder(item); + } + + @Override + public void onBindViewHolder(StockViewHolder holder, int position) { + + cursor.moveToPosition(position); + + + holder.symbol.setText(cursor.getString(Contract.Quote.POSITION_SYMBOL)); + holder.price.setText(dollarFormat.format(cursor.getFloat(Contract.Quote.POSITION_PRICE))); + + + float rawAbsoluteChange = cursor.getFloat(Contract.Quote.POSITION_ABSOLUTE_CHANGE); + float percentageChange = cursor.getFloat(Contract.Quote.POSITION_PERCENTAGE_CHANGE); + + if (rawAbsoluteChange > 0) { + holder.change.setBackgroundResource(R.drawable.percent_change_pill_green); + } else { + holder.change.setBackgroundResource(R.drawable.percent_change_pill_red); + } + + String change = dollarFormatWithPlus.format(rawAbsoluteChange); + String percentage = percentageFormat.format(percentageChange / 100); + + if (PrefUtils.getDisplayMode(context) + .equals(context.getString(R.string.pref_display_mode_absolute_key))) { + holder.change.setText(change); + } else { + holder.change.setText(percentage); + } + + + } + + @Override + public int getItemCount() { + int count = 0; + if (cursor != null) { + count = cursor.getCount(); + } + return count; + } + + + interface StockAdapterOnClickHandler { + void onClick(String symbol); + } + + class StockViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener { + + @BindView(R.id.symbol) + TextView symbol; + + @BindView(R.id.price) + TextView price; + + @BindView(R.id.change) + TextView change; + + StockViewHolder(View itemView) { + super(itemView); + ButterKnife.bind(this, itemView); + itemView.setOnClickListener(this); + } + + @Override + public void onClick(View v) { + int adapterPosition = getAdapterPosition(); + cursor.moveToPosition(adapterPosition); + int symbolColumn = cursor.getColumnIndex(Contract.Quote.COLUMN_SYMBOL); + clickHandler.onClick(cursor.getString(symbolColumn)); + + } + + + } +} diff --git a/app/src/main/res/drawable-hdpi/ic_dollar.png b/app/src/main/res/drawable-hdpi/ic_dollar.png new file mode 100644 index 0000000000000000000000000000000000000000..3f3e34d9b26090e184e52cc7e9f19ca0c5e502cd GIT binary patch literal 912 zcmV;B18@9^P)fAcE^WE=r_Blk~n%%qiclQ6c*4lfmy~RIn`p5NC2l(3&tViI#jewbr z1U4stcO@+?1GcmjGPBXZ)jsPi`UAay&dK;E;2v-rI4|i< zQR!4j1k9`*uo##Iw5}q~VGaO?Bz=zsi3TvU4!|y;?{A8^2&|8VC<4Gw8b5LJ*ltN4 zjocOmU}gh>eHp8N1FirMfL6e;WM70+KLS%?_CzeeT3~7hz&c46f(^bBn3XYir=-Jq zLl6sa1n3hi{!r4KP>`9m1fZPKRVNPQIbdI7c;YMz^Gv0g`^3& z)I;2Tz|2kpJ%h!sOIlI^!26+z!C0fD@P9S)#71BzFfBx9 z25gYz)wfiO1?UKP8g77ft!Wi#uYyv%ts*Yu>AUf7>n9s!qtQ<6T!iud0a29N^rZ~8^w+iP#^-2COv zTj=*ih)#c_aDWtuUvfqyf3KG0o-f?$0F_*7X8vZ{^kU%`{L6*Azl=RlhREi=Sy~GH mDUdqApYn8RmADQN>46`w_x>?iMFi{s0000UnY&M7@ER{$rf-;Flhe*`03@S~6ED9=` zw1Makqi7JcKy1Q_Y}&En`yQv$eea%o-@Q*By#3GPox8uY_d0u@b@tw3kc$Sn{|o`x z*by9xz@UmiL~H{L2TlSG0Ja5w2UY_g0!t*V8AwpYDHIXM0Cxa;_Tk`fz-&qL1`0$G zfQUFAxF6W6(6M=v9xT-Dms(Q*5wRoi46s`ZmIAm=((>NEiHIG5^^&aHwv+%E3*3-d z_!4*k_zc(`7zdo1>AWLpLL<*2ViRB%usJYC(p&8!C;>1BI5IKdJik!VH}zUXYz8a< z4oUR>0ES8WHFqu|&IcwZ>u&%zwG)jJ0L!xUSuW|?22PC!^7Tt3IZ8be5sui?z)s1s zFTNwvvXlUL9oR0}d6}e14FHS)Zp+rkN%}Yga3^q9vi3DFN|GbnvJ5DIh&UE_6nbhf zU*HLn-fh|Q>VpyhuV&$XP0}q5B5)~ibGANK(kEVvh^>LAfPE63=Ox|MuJit`1c3AP z;Kazcz`2tC%u?eX;PlLy;gYOx0M`IlCcm!(E|&CTw*lO0*2#=40%p`8BH}dQZoq6* z%W6sIRL&n*u~hmHPL=dRf1EFkz@dOkgH1DIKH1MJhO$l`&4(q;jR>!sVU9|^Utz{- zhcwaKO%{Gb7iGVB8+Q#2i-oIaZx+QvT0cf^yM3`;N`THiiOC`CV=%{oH zfUD5U6Hk8tE|Tio3)eh;|boF5Uc|IK86;10?T(B-%9$3jVOmjdZDfb)PUiE&@>k&;$bW%P95umb1Y z0p2Ic7r#&G7=Vb_wW{;Y{k6E;nps`y#{s|CrLsVhyS@Pfkk|QcJI(nUBH{}7$PGMk zDdLOmbn*eD@)vNKq)+=o(2)p4#0kJdNlx3iYn>0Od$BYd$GDQ6BIy-7S4GG#{n?qb zizMCKRR9rTwpmy`Y_+Y$k{l5`w;%9a=7a}e)6%sHgn_0hxKh&SZUeX)xGFJX&Uc;v zT?OFisv1rG_#drSx{jh>@LJYMI-_dj$nBC|tpAUQ~tV6YvbSmbH@3?05t!&i7-}bhZ-_I|DBR?kQ?9HM-&V>-(=ng!gi}k&bXa zlH_?)uhJHcMuf-eqpIG(C3O$yH?kBFe#FvLvzq5kZZ+MSnyFj>`ogF3h@>Yv4j?%- zQ=Y5NH=7J{-3T>(RWnCDtr#K6tk&5G^tEAczeR*+Nh1rtbqzI9l4quUN?R$^Y|~!S z$hMr%o@A%Ao2z?XR_y=jlyFi`E(VPGP002ovPDHLkV1jJLbg%#b literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-mdpi/ic_dollar.png b/app/src/main/res/drawable-mdpi/ic_dollar.png new file mode 100644 index 0000000000000000000000000000000000000000..6cd6bae76091acd2b2a030b97d59d1647bfbe1df GIT binary patch literal 631 zcmV--0*L*IP)2E0n32P31GLRxBuJ$+jD@Uz&2odhu}NlnxqF!K#EIXdp>X#SX3i$ zUDBmeh$a9RfVElTkHAY{Hn0+yl&(2klJuekq6i>a|1=XB2BPj?L&Ww@;8Z3!BZFryLx&PaMxBJ!tuiX2FFJ_H=@NcIM}8}>{3-Ug-#z~t0uJGuyc2JQeitHvya zDF(#}Tp`59n)A#gA2g<(nErsX%FQh+tU#q8-ZAl7bt1H>}g1uV#}$2gv=ef`ptFcR55 znS|={#&^L1NuzZ)#`Pix5Es&G6VHJGNh2lVjR3N-i_fv;z!qRT5c7To zcqQpWsc>~)u>+lnZEuRVO~MD83ikqF1JDn=mK3YFRkU`Xm0FjFCIH6WfnO=Ct09$y RZD9Za002ovPDHLkV1m=H8+-r& literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-mdpi/ic_percentage.png b/app/src/main/res/drawable-mdpi/ic_percentage.png new file mode 100644 index 0000000000000000000000000000000000000000..7bdfa1635733822e07d6271d79e4d9573299cbfa GIT binary patch literal 884 zcmV-)1B?8LP)D5eq5Y(WEKtU}vQ5noA+e3j9l7eKHQAOZWU`Vds548k?8c0XVzTz%Xh zN&2iS22})(0KIbY97&xekj=monXi$wwKTUHcqa3el6JL9;3&{D7f+Y;T?yn}U}Wa& zC50l`9tEt*@o#|HlKyIyz#-u7T-+w<>k@$vfk!icN76Riy;J%=z$IXcq@TJ1kNK)A z_yBk;H#iKuCh4;60Nw=Lk#qAUb=Z!I8JA<5Bn8P@QAOZcU`1(%vq1bF1iIyToNyBG zIIuAf^8+wd(v@21RSM*t&Ie{xd~+Ij6*!gB4*&x6rSf~JL!v7ujMI$;qWq%t!U>N7 zdnBE=y%3m|KwBiOtpi&ArsZa2dob{EUdb=OL`fI_7Xr599Ypy(6cq@(A}N$r3Pq0lFi zHZ)?;6oKrL@0UDc84#wm19%_-{)}dnqzW^Osb!K5TuY)^0xtkd3xkrh*ml@**mFd< z;5#6fr)dSQUC=1cHoXQ2qK%?G{^U0L zgHr1a)Fcrm6cP^y`esSSReTAw7jNc2QJ@aNs&8(Z0oc4H0000< KMNUMnLSTZne2;ek literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-nodpi/stocks_widget_preview.png b/app/src/main/res/drawable-nodpi/stocks_widget_preview.png new file mode 100644 index 0000000000000000000000000000000000000000..1e14629b026470a7de7f4911b85b6f2260096090 GIT binary patch literal 48647 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 Q>#_oz9p1L)Pygiq0bgu2M*si- literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-xxxhdpi/ic_dollar.png b/app/src/main/res/drawable-xxxhdpi/ic_dollar.png new file mode 100644 index 0000000000000000000000000000000000000000..4ae2e17bbbbe96745d0495780ad9de2192778304 GIT binary patch literal 2629 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable-xxxhdpi/ic_percentage.png b/app/src/main/res/drawable-xxxhdpi/ic_percentage.png new file mode 100644 index 0000000000000000000000000000000000000000..09d857de5aacb7fdf64ca3862ce8449b0bae860e GIT binary patch literal 3930 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable/fab_plus.xml b/app/src/main/res/drawable/fab_plus.xml new file mode 100644 index 0000000..7a65b19 --- /dev/null +++ b/app/src/main/res/drawable/fab_plus.xml @@ -0,0 +1,9 @@ + + + diff --git a/app/src/main/res/drawable/percent_change_pill_green.xml b/app/src/main/res/drawable/percent_change_pill_green.xml new file mode 100644 index 0000000..027c6a5 --- /dev/null +++ b/app/src/main/res/drawable/percent_change_pill_green.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/drawable/percent_change_pill_red.xml b/app/src/main/res/drawable/percent_change_pill_red.xml new file mode 100644 index 0000000..e5ce5f3 --- /dev/null +++ b/app/src/main/res/drawable/percent_change_pill_red.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml new file mode 100644 index 0000000..40f6e87 --- /dev/null +++ b/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,46 @@ + + + + + + + + + + + + + diff --git a/app/src/main/res/layout/add_stock_dialog.xml b/app/src/main/res/layout/add_stock_dialog.xml new file mode 100644 index 0000000..7a54cc8 --- /dev/null +++ b/app/src/main/res/layout/add_stock_dialog.xml @@ -0,0 +1,18 @@ + + + + + + diff --git a/app/src/main/res/layout/list_item_quote.xml b/app/src/main/res/layout/list_item_quote.xml new file mode 100644 index 0000000..91c5d51 --- /dev/null +++ b/app/src/main/res/layout/list_item_quote.xml @@ -0,0 +1,43 @@ + + + + + + + + + + + + diff --git a/app/src/main/res/menu/main_activity_settings.xml b/app/src/main/res/menu/main_activity_settings.xml new file mode 100644 index 0000000..1d7e021 --- /dev/null +++ b/app/src/main/res/menu/main_activity_settings.xml @@ -0,0 +1,12 @@ + + + + + + diff --git a/app/src/main/res/mipmap-hdpi/ic_launcher.png b/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..cde69bcccec65160d92116f20ffce4fce0b5245c GIT binary patch literal 3418 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..bfa42f0e7b91d006d22352c9ff2f134e504e3c1d GIT binary patch literal 4842 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..324e72cdd7480cb983fa1bcc7ce686e51ef87fe7 GIT binary patch literal 7718 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..aee44e138434630332d88b1680f33c4b24c70ab3 GIT binary patch literal 10486 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 + + + @string/default_stocks_apple + @string/default_stocks_yahoo + @string/default_stocks_microsoft + @string/default_stocks_facebook + + diff --git a/app/src/main/res/values/colors.xml b/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..756a300 --- /dev/null +++ b/app/src/main/res/values/colors.xml @@ -0,0 +1,13 @@ + + + #3F51B5 + #303F9F + #FF4081 + + + #1976D2 + #2196F3 + #D50000 + #00C853 + + diff --git a/app/src/main/res/values/dimens.xml b/app/src/main/res/values/dimens.xml new file mode 100644 index 0000000..fe991af --- /dev/null +++ b/app/src/main/res/values/dimens.xml @@ -0,0 +1,4 @@ + + 16dp + 16dp + diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..910735b --- /dev/null +++ b/app/src/main/res/values/strings.xml @@ -0,0 +1,39 @@ + + Stock Hawk + + initialized + + stocks + + No data + + + Display Mode + displayMode + @string/pref_display_mode_percentage_key + + absolute + percentage + + YHOO + AAPL + MSFT + FB + + + @string/pref_display_mode_key + + + Add Stock + Symbol (e.g. GOOG) + Cancel + Add + + Symbol %s is invalid! + No network connectivity! Will load stock cursor when the network is available. + No stocks added! Hit the floating action button to add one. + + Symbol %s added. Will refresh when network available. + Will refresh when network available. + + diff --git a/app/src/main/res/values/styles.xml b/app/src/main/res/values/styles.xml new file mode 100644 index 0000000..29570a4 --- /dev/null +++ b/app/src/main/res/values/styles.xml @@ -0,0 +1,23 @@ + + + + + + + + + + diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..6ed72f0 --- /dev/null +++ b/build.gradle @@ -0,0 +1,23 @@ +apply plugin: 'com.github.ben-manes.versions' + +buildscript { + repositories { + jcenter() + } + dependencies { + classpath 'com.android.tools.build:gradle:2.2.2' + classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' + classpath 'com.github.ben-manes:gradle-versions-plugin:0.12.0' + classpath 'com.noveogroup.android:check:1.2.3' + } +} + +allprojects { + repositories { + jcenter() + } +} + +task clean(type: Delete) { + delete rootProject.buildDir +} diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..1d3591c --- /dev/null +++ b/gradle.properties @@ -0,0 +1,18 @@ +# Project-wide Gradle settings. + +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. + +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html + +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +# Default value: -Xmx10248m -XX:MaxPermSize=256m +# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 + +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true \ No newline at end of file diff --git a/gradlew b/gradlew new file mode 100644 index 0000000..9aa616c --- /dev/null +++ b/gradlew @@ -0,0 +1,169 @@ +#!/usr/bin/env bash + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS="" + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn ( ) { + echo "$*" +} + +die ( ) { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin, switch paths to Windows format before running java +if $cygwin ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=$((i+1)) + done + case $i in + (0) set -- ;; + (1) set -- "$args0" ;; + (2) set -- "$args0" "$args1" ;; + (3) set -- "$args0" "$args1" "$args2" ;; + (4) set -- "$args0" "$args1" "$args2" "$args3" ;; + (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules +function splitJvmOpts() { + JVM_OPTS=("$@") +} +eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS +JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" + +# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong +if [[ "$(uname)" == "Darwin" ]] && [[ "$HOME" == "$PWD" ]]; then + cd "$(dirname "$0")" +fi + +exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..f955316 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,84 @@ +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS= + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto init + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto init + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:init +@rem Get command-line arguments, handling Windows variants + +if not "%OS%" == "Windows_NT" goto win9xME_args + +:win9xME_args +@rem Slurp the command line arguments. +set CMD_LINE_ARGS= +set _SKIP=2 + +:win9xME_args_slurp +if "x%~1" == "x" goto execute + +set CMD_LINE_ARGS=%* + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/settings.gradle b/settings.gradle new file mode 100644 index 0000000..e7b4def --- /dev/null +++ b/settings.gradle @@ -0,0 +1 @@ +include ':app'