From a1de0d5d1ef1eb0eb8d1291d14bd5df530ea9f92 Mon Sep 17 00:00:00 2001 From: "Chris J. Karr" Date: Sat, 29 Apr 2017 19:01:02 -0500 Subject: [PATCH] Withings device work * Card for app events. --- res/drawable-hdpi/ic_page_indicator.png | Bin 0 -> 1340 bytes res/drawable-mdpi/ic_page_indicator.png | Bin 0 -> 1190 bytes res/drawable-xhdpi/ic_page_indicator.png | Bin 0 -> 1489 bytes res/drawable-xxhdpi/ic_page_indicator.png | Bin 0 -> 1856 bytes res/drawable-xxxhdpi/ic_page_indicator.png | Bin 0 -> 2035 bytes res/layout/card_generator_app_event.xml | 20 +- res/layout/card_generator_app_event_page.xml | 186 ++++++ .../card_generator_withings_activity_page.xml | 114 ++++ .../card_generator_withings_body_page.xml | 13 + res/layout/card_generator_withings_device.xml | 121 +--- .../card_generator_withings_info_page.xml | 13 + .../card_generator_withings_intraday_page.xml | 71 +++ .../card_generator_withings_sleep_page.xml | 13 + ..._generator_withings_sleep_summary_page.xml | 13 + .../card_generator_withings_workouts_page.xml | 13 + res/values/generators.xml | 5 + .../activities/views/ViewPagerIndicator.java | 92 +++ .../generators/device/Battery.java | 3 - .../generators/diagnostics/AppEvent.java | 144 ++++- .../generators/sensors/AmbientLight.java | 312 +++++++++- .../generators/wearables/WithingsDevice.java | 554 ++++++++++++++++-- .../transmitters/HttpTransmitter.java | 3 +- 22 files changed, 1513 insertions(+), 177 deletions(-) create mode 100755 res/drawable-hdpi/ic_page_indicator.png create mode 100755 res/drawable-mdpi/ic_page_indicator.png create mode 100755 res/drawable-xhdpi/ic_page_indicator.png create mode 100755 res/drawable-xxhdpi/ic_page_indicator.png create mode 100755 res/drawable-xxxhdpi/ic_page_indicator.png create mode 100755 res/layout/card_generator_app_event_page.xml create mode 100755 res/layout/card_generator_withings_activity_page.xml create mode 100755 res/layout/card_generator_withings_body_page.xml create mode 100755 res/layout/card_generator_withings_info_page.xml create mode 100755 res/layout/card_generator_withings_intraday_page.xml create mode 100755 res/layout/card_generator_withings_sleep_page.xml create mode 100755 res/layout/card_generator_withings_sleep_summary_page.xml create mode 100755 res/layout/card_generator_withings_workouts_page.xml create mode 100755 src/com/audacious_software/passive_data_kit/activities/views/ViewPagerIndicator.java diff --git a/res/drawable-hdpi/ic_page_indicator.png b/res/drawable-hdpi/ic_page_indicator.png new file mode 100755 index 0000000000000000000000000000000000000000..0bc147b66e91b3edae08ccc1f295fc1c3cef03cb GIT binary patch literal 1340 zcmeAS@N?(olHy`uVBq!ia0vp^LLkh+1|-AI^@Rf|$r9IylHmNblJdl&R0hYC{G?O` z&)mfH)S%SFl*+=BsWuD@%o>>?5hW46K32*3xq68pHF_1f1wh>l3^w)^1&PVosU-?Y zsp*+{wo31J?^jaDOtDo8H}y5}EpSfF$n>ZxN)4{^3rViZPPR-@vbR&PsjvbXkegbP zs8ErclUHn2VXFi-*9yo63F|8hm3bwJ6}oxF$}kgLQj3#|G7CyF^YauyCMG83 zmzLNn0bL65LT&-v*t}wBFaZNhzap_f-%!s0*lEl2^R8JRMC7?NanVBh8W(KYnZYE|XZZ5_KhK8=Djs})47M2E< zhL&a~u7;M5FugAM$)&lec_lEtDG0r$IQ4=OL~a4lW|!2W%(B!Jx1#)91+d4hGI6`b z2&Z{ay(zfeVvJL-KF~4xpy)-4ZkP}-4S|^O#0%uWlYeR+FwGYM6ZdBh4L$}2##Np! zjv*DdlJ-=8*JC#O@cO!b+xqzZi#j%L+-O)(R0K@1hKVcEMMOkg1b_Vgt}k)>)-9us zj*bi_)051tk&QpTPS=lL7rUe2;pNZI&r4cZSV(+eDl02%>+9?DSnz1^e<1iL&sp>P z+uMWR-rm0L>*M3{L2A*GB}XbhJvrI>pOaz1={yxRwOI+KE$!{?FR!c&?*1>#`R~uq z&qpp^4CFn$;M=!vGybbIS(m@ddHn2|TZ@gny!`9U>F3Y=Q)g~zZN1rWhGBMETG}#Q zP0f|Z9oRm6{`|Q?n#D)D%b}}Prg_JX9VQRi8ZSvP|7?)W6EI-hr+i&x!9DSU=5;YU ziTWB0r7@qAeT1o;HgU~8?oT}N_?p*dZnQ7Lr+1c0uCk@-B4OD}(GbfuNor^QG z+1aq#rf>S76fp%;1z(i5*hU|G(9q4phSCO;1;L;XidK=hihZc1MU(N&HkcPFb=bmR5`c z1cD|NVGc@4<<)Dj55t0CH9z8vh%a)op%IdgAzaNwYz*t`cTGv2fDS0YqN=CxKfkQu zKvh!sv4lv8W(JO{ho&reWNIicPff_Ig7-fU`dkhPXwZ>>tDVqo&Q0MhT@LO2Fo}Z} z#F3arDA;^(l+9Ac zxEw#YnG2m#__*Vk97&eTWuhD-468`eEX$Hql#E6r2obR>x+A#}-QL$$;Gr#Bs_CeP z4tzzaV3eE`jw-#^f@W^X>h|WC(7;GnGD(`C{Fd54QT%_Xrfs2ZCkOA>`#@nkUojz> zgSJt!WOQ+3`}|ZUm$9Ja7*^gePPC^uJZ?CKJ#LsFlW9#2ghfeKbwAkCVu>Or=(Z#2 zG8Fg}j&ulBRXB!@W-`44%pf15XgZrnQ!L-hQY_6T<5`+bx4FC_mo%t5ZLV^k+q*5- zH-u)Q%sjNzNvI53h6Y-VbLsAb7U&ZAbl&~0u-0tK*tF+)v8uQ6{`BnZ?DUy4k33xu)x9gP zuU}tSUS3|P*F#4io|z65i^V_Y=jY>sAjH7g^`*1q>P+PL=kD@3_TZjIx>Bix8Z#^2 zr>EZCe{AxzxjE2vkmG*C7Hi(s;Dw79AN_IfH=i75ZuAFk-dg*5samZ*0aoTluT<|I zc&hWHx3T_VAOtSQg7o7-X<v$Alm(P-=*7<%GV)x+>`iO8i{Fc7Im`;ZH zWAR$gGu_=EciaL?&DG0K)?WMjv7c)mRXK$PvC%hoe}8`E_AmaQL&y&Cmj+%r{Vyu~ Bq}>1j literal 0 HcmV?d00001 diff --git a/res/drawable-xhdpi/ic_page_indicator.png b/res/drawable-xhdpi/ic_page_indicator.png new file mode 100755 index 0000000000000000000000000000000000000000..a1900c614ebce2509a6f9fe978414647aa90a046 GIT binary patch literal 1489 zcmaJ>ZA=qq96#s^LPL}xBI?F*>MUw|*H`F4p^O&oSPN?#z`11{?NuuD?z}st=mzpu zC+Zv+9m^u1e4xY)7;YdN2u?8IHj){Wjk$%v)Q_x4qLN{|D+2Dr*pu8n&-2gk_xr!* zIhkYJ6A`{C8~}g_{a&q!+cyTjH6h&pk5cthZi{7g`K+0=v!xh~1L-!h5C`>6>;P`U zFFlFCpyg36`f(t;nLDlaj8s9(g$FPN~MAkDJ+$WIE08PBUsEOBABhq3R;}8 z(hiDskOUY|#0ts7tQz7XeV&4oT9GA~r802^gIyQ}OTcH22@WlEJj#yy;cozI%0>zhAI(VQl?yqWNKxIM50rqBPwl@3QG)oD}C-i_?xHxGj?=o#0~PsAJVw6uMRQmbkW6V^L(T%7wXL z;6Qu-)$U~zH$#Er%J6cRmGQ?3ZsuujxX(0(d;+-%EkruJ(_`C(yU(%jr!V?#qjuBIb+-PNGkWbium z=>8aQe=ngv;#-)n*mms4u`&JAyY1$SL*Vm~F2QEPoOlY@g<2E&=!7XHM<#6wL)r|(=)$2)z}bIr}ov29a5Jw4O!4VDkgHwSmo z4{k#_!&bm(G`d^&oPGSPZA<^$+?;u&Yv|4$Q>1YILimP-$?G2+i*fVKZAQbh?Cro0 zF?p4d$c48iwJ{%QZDMJL~vE_Y<;5UapENY7%zyHK|)SpFb6!yI$b) zJ^Q<|&Ru@Ut^AHdDWT29Q^8zM%awDCe#3M{eARPd+p~{5VjE9k;w! z@;YBVL{U^IUI^NESj^IlcjHS4Vy4?QJH0QvDWxxh-qwAo!naUXHa&c@dgyk$hFg43 z)7sCbu9Xy4?F=b9|4M#bmM}O7`Kac&s)^s2Fj&qtZ=zNZGsAn3#+xNUU)XSk=F`)^ xywMzaFmjh%hd}KoVjsmEO#1NF+q1lvHUhfZRwmA}y)*F0>UBnK$Lj@E{{Sb`F)siB literal 0 HcmV?d00001 diff --git a/res/drawable-xxhdpi/ic_page_indicator.png b/res/drawable-xxhdpi/ic_page_indicator.png new file mode 100755 index 0000000000000000000000000000000000000000..af86b8c9318758363f9dcf8ce81e088736bf388c GIT binary patch literal 1856 zcmaJ?X;c$e6b>khAY~B|Xw+#y3nIxRge8%%m_#S`buFfkJ^|g(DgT*H#KzK@sf)Mf*cL=ghqK?z!K0zq`CMTjPX_ z9PB*p2n2!yKZ+y5S8wxcYmI+RgrXvR@xZuCu>>Ru(@0b>AreB?zyMz%NrpwR1j<-@ z84e{7Ci%z`mtso=F-$3I@|&(fTXZUK0!) zSS?k_P)vp>0W+gy4U&$rNVwA1DJamlv`Y1xGT{ZIXeB6xN(Rj-O*je!|L>|$y!BRN zBKV!&_Y$iUGfA?g$a1=#HIssTO% ziBzUE8-2%70s)h+RAUmQ6y|eSB%FsVlR?ZNkQ>6I2eNsb0FX-M21bGmP6z{JP#HmV zE|n2Ef#o35bOo%$Ca};uEa!t*^FSz2JTeDX$=1OTPlYIe@x+<3_h_N>IP4I5FqOxl z@!qfHH5Pi0mN!`12eA}f48`2u|FnC;gwK$9`*wKo!`tzPmH5o7@Zok`aKRV9GZlPJ zWTLjaxoA~XLOiii^J8_mqJo-yB3y2r)>I#LyvUSI+vww@iQ9uPF$y%#XEMYU4<8&>YsPLi>i+t3f9u$O z^`_bZ51o_Ci`Yn;>^kWf;FdoHq7_GYyYv(FF>{A2L`P3)W82!>PuT2^O%#jmQ&UsF zI?~23>F(*NY^QJB_kF2-p=T6z{w9~91ycu=a`}e6#l=%b#$Mj?Ike;ls}(C&bocl7 z+vxTBd~mHRE&HsOgU3gcEgu<;#-8-_bl7EU-;>p;X=!r^D#y8lC0}2BGBPqEDBvZ8 z#Kgw#@O8B_#+jV;2M%m%@9e}>N3E@`$w{WxKZ*{zDIDXJ8j82D|rgV07EwRcT3ni39 zc@Nd4p59jUjcGY~N8@An!5KZmBOSl)Uv;@#Afe)7PSve8Fu-q0i2!a+5{qBwfkYSHP%yRn|R& z!O$8pnkU{127Q}#TE3v5uCLJZK8wNGJI52djoaS zvU?v*HHDy-@$LmYzq3ro*$+0iWLRg$wkvIWmaM`z!9Ol%f67=&k{A6&T-?Wa97eDR>itXW^!sc*hC zFr#NaU0L5b-7UZWN_~BOPXffZYz{CkSJn@I>UiK}aYA!@?k|Aej0RPVA$r!;lnjCLSc>CxO|oA zq~e9617u0FGOA0fS}o>~K8}q(_xE0VMUb9fc~zV>yTRIifZ=Ix>5%C+Ye$|~EUrCP zUY>J##MR!XW%1<4R%;r-)U8v9SM`xqWns&Xxqh~D#Sm*=->XmVSj$u$-th%<#S*vW jxqW260Aobah~GIvUzqLHrUAKw`Jcw;3ON-ES8w?jEVtqj literal 0 HcmV?d00001 diff --git a/res/drawable-xxxhdpi/ic_page_indicator.png b/res/drawable-xxxhdpi/ic_page_indicator.png new file mode 100755 index 0000000000000000000000000000000000000000..6a92866f6cd93dbbf698796a44c62dc630d916b9 GIT binary patch literal 2035 zcmaJ?Yg7|w8XiE(MJS4Z;nFfhL~O|oLSh1uO9Ca3fFd_5EQVx&NG21L5dvZh+8}r- zSd;>`QhN$2EZP8KsiJ^dD`k^%5%5-^utJMjV=bBr(w$IY_s6nx&dm3H?|Gl+y*=NV zk}c8i*;>0;0{~#ljo`#$E7|y3zJYxcP5(HEEzW3I61ojZM{@*n2nZ1&X%NVT1sPB* zBoO89z6}KefSI>AE(uNI^O!;eCJKx`L?tZ4&;Sq^q?8GSSr7`QK^bBx3;*QuH9RO5 zvG9rhd@^6ghBCzwd2(o5UUZx=FH6V};e$4Vfl4Mu07Iw%RKgOef~jQT7kHW2-e@M_ z!37sIi-rFysU-dukd4S8(4R;n2+1@$NM{f!{&YH(?gRRgDgGp~AIXnQ@bzO-$xNy* z`1-+P(d43ZW-KTCbu8?}!e^qWj7cKpFc@Px2QdFQM zNEPcA890zaC>P66F(L(xjDj>|56Z%0nf_G*EL)kdY`vvazH^M?U}m zyTb62w*rlY{*&+jBv!=b${B;g-o2MM*q0=i+#0vz z_2-MX559N5b!bznso9_3?KRkpbmmYj6zh8(&2C*3@?v5v)|A{}ziCi0s6Cy@2GAp~ zO(nTtn3|fhdV6m5WJFUR!75e1U2{Z~*zV~75( zB3bDW?MASVhimQi7cXA8bG^!uB$bVNRdd{GXM;wgIq+aCD?z~K-T0}&@~BrHoldVI ze`=%d9F5~V-#_C+AUqThT|Z2JV1BrKrE6-vGY)5|Kd4Q-WIpPFvsOj-J>jpB z)+slt>~eMLbMG+J;s9DJuRnQfeDG%4cHr=>@tSzYV2Mvnfuy;lv9WPqTs)953pRB- zcep;En3xENH|Ozq1^=jME_2-PG9HnVl0rTaNoYv0D72F7{7P6yL_EBk)6_}3cJF?A zVpoHm*Vl#WADx;A`2djoxan65>MO&Awzjsl(#~hFo9Tg;mw8)Z$8S^2_jiuAMR?k0pFZsvE+Maq+6tf0edpxv zol?4PAAvwvo0yn5l3@J-1VJ_w@wD59iZ5MuFdD<|Mb6}}I9Xk-(P}hB-L|E;VpXNX z{U - - + + - + android:layout_height="match_parent"> + + diff --git a/res/layout/card_generator_app_event_page.xml b/res/layout/card_generator_app_event_page.xml new file mode 100755 index 0000000..9134d02 --- /dev/null +++ b/res/layout/card_generator_app_event_page.xml @@ -0,0 +1,186 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/res/layout/card_generator_withings_activity_page.xml b/res/layout/card_generator_withings_activity_page.xml new file mode 100755 index 0000000..35251ab --- /dev/null +++ b/res/layout/card_generator_withings_activity_page.xml @@ -0,0 +1,114 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/res/layout/card_generator_withings_body_page.xml b/res/layout/card_generator_withings_body_page.xml new file mode 100755 index 0000000..91befe4 --- /dev/null +++ b/res/layout/card_generator_withings_body_page.xml @@ -0,0 +1,13 @@ + + + + diff --git a/res/layout/card_generator_withings_device.xml b/res/layout/card_generator_withings_device.xml index 6675ceb..96f1fec 100755 --- a/res/layout/card_generator_withings_device.xml +++ b/res/layout/card_generator_withings_device.xml @@ -26,127 +26,30 @@ android:layout_marginRight="8dp" /> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + android:layout_height="160dp"> + + + diff --git a/res/layout/card_generator_withings_info_page.xml b/res/layout/card_generator_withings_info_page.xml new file mode 100755 index 0000000..4ce8198 --- /dev/null +++ b/res/layout/card_generator_withings_info_page.xml @@ -0,0 +1,13 @@ + + + + diff --git a/res/layout/card_generator_withings_intraday_page.xml b/res/layout/card_generator_withings_intraday_page.xml new file mode 100755 index 0000000..3b1086d --- /dev/null +++ b/res/layout/card_generator_withings_intraday_page.xml @@ -0,0 +1,71 @@ + + + + + + + + + + + + + + + + + + + diff --git a/res/layout/card_generator_withings_sleep_page.xml b/res/layout/card_generator_withings_sleep_page.xml new file mode 100755 index 0000000..5c6a9d5 --- /dev/null +++ b/res/layout/card_generator_withings_sleep_page.xml @@ -0,0 +1,13 @@ + + + + diff --git a/res/layout/card_generator_withings_sleep_summary_page.xml b/res/layout/card_generator_withings_sleep_summary_page.xml new file mode 100755 index 0000000..c4a7d6f --- /dev/null +++ b/res/layout/card_generator_withings_sleep_summary_page.xml @@ -0,0 +1,13 @@ + + + + diff --git a/res/layout/card_generator_withings_workouts_page.xml b/res/layout/card_generator_withings_workouts_page.xml new file mode 100755 index 0000000..2be7a18 --- /dev/null +++ b/res/layout/card_generator_withings_workouts_page.xml @@ -0,0 +1,13 @@ + + + + diff --git a/res/values/generators.xml b/res/values/generators.xml index 20e06bd..c304b38 100755 --- a/res/values/generators.xml +++ b/res/values/generators.xml @@ -127,6 +127,11 @@ #039BE5 #43A047 No activity data has been downloaded yet. + Info coming soon… + Steps + Distance + Elevation + Calories Steps %1$d steps diff --git a/src/com/audacious_software/passive_data_kit/activities/views/ViewPagerIndicator.java b/src/com/audacious_software/passive_data_kit/activities/views/ViewPagerIndicator.java new file mode 100755 index 0000000..e1ca120 --- /dev/null +++ b/src/com/audacious_software/passive_data_kit/activities/views/ViewPagerIndicator.java @@ -0,0 +1,92 @@ +package com.audacious_software.passive_data_kit.activities.views; + +import android.content.Context; +import android.util.AttributeSet; +import android.util.DisplayMetrics; +import android.view.View; +import android.view.ViewGroup; +import android.widget.ImageView; +import android.widget.LinearLayout; + +import com.audacious_software.pdk.passivedatakit.R; + +import java.util.ArrayList; + +/** + * Created by cjkarr on 4/27/2017. + */ + +public class ViewPagerIndicator extends LinearLayout { + private final LinearLayout mIndicatorLayout; + + public ViewPagerIndicator(Context context, AttributeSet attrs) { + super(context, attrs); + + LinearLayout.LayoutParams borderParams = new LinearLayout.LayoutParams(12, 12); + borderParams.weight = 1; + + View left = new View(context); + left.setLayoutParams(borderParams); + left.setVisibility(View.VISIBLE); + + this.addView(left); + + this.mIndicatorLayout = new LinearLayout(context); + this.mIndicatorLayout.setOrientation(LinearLayout.HORIZONTAL); + + LinearLayout.LayoutParams indicatorParams = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT); + this.mIndicatorLayout.setLayoutParams(indicatorParams); + this.mIndicatorLayout.setVisibility(View.VISIBLE); + + this.addView(this.mIndicatorLayout); + + View right = new View(context); + right.setLayoutParams(borderParams); + right.setVisibility(View.VISIBLE); + + this.addView(right); + } + + public void setPageCount(int count) { + ArrayList toRemove = new ArrayList<>(); + + for (int i = 0; i < this.mIndicatorLayout.getChildCount(); i++) { + toRemove.add(this.mIndicatorLayout.getChildAt(i)); + } + + for (View view : toRemove) { + this.mIndicatorLayout.removeView(view); + } + + DisplayMetrics metrics = this.getContext().getResources().getDisplayMetrics(); + + for (int i = 0; i < count; i++) { + ImageView indicator = new ImageView(this.getContext()); + + indicator.setScaleType(ImageView.ScaleType.CENTER_INSIDE); + + indicator.setPadding((int) (3 * metrics.density), (int) (3 * metrics.density), (int) (3 * metrics.density), (int) (3 * metrics.density)); + + LayoutParams params = new LayoutParams((int) (12 * metrics.density), (int) (12 * metrics.density)); + indicator.setLayoutParams(params); + + indicator.setImageResource(R.drawable.ic_page_indicator); + + this.mIndicatorLayout.addView(indicator); + } + } + + public void setSelectedPage(int position) { + DisplayMetrics metrics = this.getContext().getResources().getDisplayMetrics(); + + for (int i = 0; i < this.mIndicatorLayout.getChildCount(); i++) { + View view = this.mIndicatorLayout.getChildAt(i); + + view.setPadding((int) (3 * metrics.density), (int) (3 * metrics.density), (int) (3 * metrics.density), (int) (3 * metrics.density)); + } + + View view = this.mIndicatorLayout.getChildAt(position); + + view.setPadding((int) (1 * metrics.density), (int) (1 * metrics.density), (int) (1 * metrics.density), (int) (1 * metrics.density)); + } +} diff --git a/src/com/audacious_software/passive_data_kit/generators/device/Battery.java b/src/com/audacious_software/passive_data_kit/generators/device/Battery.java index 4d91714..f940c35 100755 --- a/src/com/audacious_software/passive_data_kit/generators/device/Battery.java +++ b/src/com/audacious_software/passive_data_kit/generators/device/Battery.java @@ -43,7 +43,6 @@ */ public class Battery extends Generator { - private static final String GENERATOR_IDENTIFIER = "pdk-device-battery"; private static final String ENABLED = "com.audacious_software.passive_data_kit.generators.device.Battery.ENABLED"; @@ -277,8 +276,6 @@ public static void bindViewHolder(DataPointViewHolder holder) { View cardEmpty = holder.itemView.findViewById(R.id.card_empty); TextView dateLabel = (TextView) holder.itemView.findViewById(R.id.generator_data_point_date); - Log.e("SLEEP-SIGHT", "BATT VALUES COUNT 1: " + c.getCount()); - if (c.moveToNext()) { cardContent.setVisibility(View.VISIBLE); cardEmpty.setVisibility(View.GONE); diff --git a/src/com/audacious_software/passive_data_kit/generators/diagnostics/AppEvent.java b/src/com/audacious_software/passive_data_kit/generators/diagnostics/AppEvent.java index ccb26e2..0319140 100755 --- a/src/com/audacious_software/passive_data_kit/generators/diagnostics/AppEvent.java +++ b/src/com/audacious_software/passive_data_kit/generators/diagnostics/AppEvent.java @@ -6,9 +6,12 @@ import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.os.Bundle; +import android.support.v4.view.PagerAdapter; +import android.support.v4.view.ViewPager; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; +import android.widget.LinearLayout; import android.widget.TextView; import com.audacious_software.passive_data_kit.PassiveDataKit; @@ -23,7 +26,6 @@ import java.io.File; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; import java.util.Map; @@ -41,10 +43,15 @@ public class AppEvent extends Generator{ public static final String HISTORY_EVENT_DETAILS = "event_details"; public static final String TABLE_HISTORY = "history"; + private static final int CARD_PAGE_SIZE = 8; + private static final int CARD_MAX_PAGES = 8; + private static AppEvent sInstance = null; private SQLiteDatabase mDatabase = null; + private int mPage = 0; + public static AppEvent getInstance(Context context) { if (AppEvent.sInstance == null) { AppEvent.sInstance = new AppEvent(context.getApplicationContext()); @@ -99,33 +106,158 @@ public static ArrayList diagnostics(Context context) { public static void bindViewHolder(DataPointViewHolder holder) { final Context context = holder.itemView.getContext(); - AppEvent generator = AppEvent.getInstance(context); + final AppEvent generator = AppEvent.getInstance(context); + + final ArrayList events = new ArrayList<>(); Cursor c = generator.mDatabase.query(AppEvent.TABLE_HISTORY, null, null, null, null, null, AppEvent.HISTORY_OBSERVED + " DESC"); View cardContent = holder.itemView.findViewById(R.id.card_content); + View cardSizer = holder.itemView.findViewById(R.id.card_sizer); View cardEmpty = holder.itemView.findViewById(R.id.card_empty); TextView dateLabel = (TextView) holder.itemView.findViewById(R.id.generator_data_point_date); + int eventCount = c.getCount(); + if (c.moveToNext()) { cardContent.setVisibility(View.VISIBLE); cardEmpty.setVisibility(View.GONE); + cardSizer.setVisibility(View.INVISIBLE); long timestamp = c.getLong(c.getColumnIndex(AppEvent.HISTORY_OBSERVED)) / 1000; dateLabel.setText(Generator.formatTimestamp(context, timestamp)); - - TextView eventCount = (TextView) holder.itemView.findViewById(R.id.card_app_event_count); - - eventCount.setText("TODO: EVENT VIEW - " + c.getCount()); } else { cardContent.setVisibility(View.GONE); cardEmpty.setVisibility(View.VISIBLE); + cardSizer.setVisibility(View.INVISIBLE); dateLabel.setText(R.string.label_never_pdk); } + c.moveToPrevious(); + + while (c.moveToNext()) { + String event = c.getString(c.getColumnIndex(AppEvent.HISTORY_EVENT_NAME)); + long timestamp = c.getLong(c.getColumnIndex(AppEvent.HISTORY_OBSERVED)); + + Object[] values = { event, timestamp }; + + events.add(values); + } + c.close(); + + if (eventCount > AppEvent.CARD_PAGE_SIZE * AppEvent.CARD_MAX_PAGES) { + eventCount = AppEvent.CARD_PAGE_SIZE * AppEvent.CARD_MAX_PAGES; + } + + final int pages = (int) Math.ceil(((double) eventCount) / AppEvent.CARD_PAGE_SIZE); + + final AppEvent appEvent = AppEvent.getInstance(holder.itemView.getContext()); + + ViewPager pager = (ViewPager) holder.itemView.findViewById(R.id.content_pager); + + PagerAdapter adapter = new PagerAdapter() { + @Override + public int getCount() { + return pages; + } + + @Override + public boolean isViewFromObject(View view, Object content) { + return view.getTag().equals(content); + } + + public void destroyItem(ViewGroup container, int position, Object content) { + int toRemove = -1; + + for (int i = 0; i < container.getChildCount(); i++) { + View child = container.getChildAt(i); + + if (this.isViewFromObject(child, content)) + toRemove = i; + } + + if (toRemove >= 0) + container.removeViewAt(toRemove); + } + + public Object instantiateItem(ViewGroup container, int position) { + LinearLayout list = (LinearLayout) LayoutInflater.from(container.getContext()).inflate(R.layout.card_generator_app_event_page, container, false); + + int listPosition = AppEvent.CARD_PAGE_SIZE * position; + + for (int i = 0; i < AppEvent.CARD_PAGE_SIZE; i++) { + Object[] values = events.get(listPosition + i); + + String event = (String) values[0]; + long timestamp = (long) values[1]; + + LinearLayout row = null; + + switch (i) { + case 0: + row = (LinearLayout) list.findViewById(R.id.app_event_row_0); + break; + case 1: + row = (LinearLayout) list.findViewById(R.id.app_event_row_1); + break; + case 2: + row = (LinearLayout) list.findViewById(R.id.app_event_row_2); + break; + case 3: + row = (LinearLayout) list.findViewById(R.id.app_event_row_3); + break; + case 4: + row = (LinearLayout) list.findViewById(R.id.app_event_row_4); + break; + case 5: + row = (LinearLayout) list.findViewById(R.id.app_event_row_5); + break; + case 6: + row = (LinearLayout) list.findViewById(R.id.app_event_row_6); + break; + default: + row = (LinearLayout) list.findViewById(R.id.app_event_row_7); + break; + } + + TextView eventName = (TextView) row.findViewById(R.id.app_event_row_event_name); + TextView eventWhen = (TextView) row.findViewById(R.id.app_event_row_event_when); + + eventName.setText(event); + eventWhen.setText(Generator.formatTimestamp(context, timestamp / 1000)); + } + + list.setTag("" + position); + + container.addView(list); + + return "" + list.getTag(); + } + }; + + pager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() { + @Override + public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { + + } + + @Override + public void onPageSelected(int position) { + appEvent.mPage = position; + } + + @Override + public void onPageScrollStateChanged(int state) { + + } + }); + + pager.setAdapter(adapter); + + pager.setCurrentItem(appEvent.mPage); } public static View fetchView(ViewGroup parent) diff --git a/src/com/audacious_software/passive_data_kit/generators/sensors/AmbientLight.java b/src/com/audacious_software/passive_data_kit/generators/sensors/AmbientLight.java index 09c7f3c..4dbedf8 100755 --- a/src/com/audacious_software/passive_data_kit/generators/sensors/AmbientLight.java +++ b/src/com/audacious_software/passive_data_kit/generators/sensors/AmbientLight.java @@ -1,8 +1,318 @@ package com.audacious_software.passive_data_kit.generators.sensors; +import android.content.Context; +import android.content.SharedPreferences; +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; +import android.hardware.Sensor; +import android.hardware.SensorEvent; +import android.hardware.SensorEventListener; +import android.hardware.SensorManager; +import android.os.Build; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.support.v4.content.ContextCompat; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.TextView; + +import com.audacious_software.passive_data_kit.PassiveDataKit; +import com.audacious_software.passive_data_kit.activities.generators.DataPointViewHolder; +import com.audacious_software.passive_data_kit.diagnostics.DiagnosticAction; +import com.audacious_software.passive_data_kit.generators.Generator; +import com.audacious_software.passive_data_kit.generators.Generators; +import com.audacious_software.passive_data_kit.generators.device.Battery; +import com.audacious_software.pdk.passivedatakit.R; +import com.github.mikephil.charting.charts.LineChart; +import com.github.mikephil.charting.components.AxisBase; +import com.github.mikephil.charting.components.XAxis; +import com.github.mikephil.charting.components.YAxis; +import com.github.mikephil.charting.data.Entry; +import com.github.mikephil.charting.data.LineData; +import com.github.mikephil.charting.data.LineDataSet; +import com.github.mikephil.charting.formatter.IAxisValueFormatter; + +import java.io.File; +import java.text.DateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; + /** * Created by cjkarr on 4/17/2017. */ -public class AmbientLight { +public class AmbientLight extends Generator implements SensorEventListener { + private static final String GENERATOR_IDENTIFIER = "pdk-sensor-light"; + + private static final String ENABLED = "com.audacious_software.passive_data_kit.generators.device.AmbientLight.ENABLED"; + private static final boolean ENABLED_DEFAULT = true; + + private static final String DATABASE_PATH = "pdk-sensor-light.sqlite"; + private static final int DATABASE_VERSION = 1; + + public static final String TABLE_HISTORY = "history"; + + public static final String HISTORY_OBSERVED = "observed"; + public static final String HISTORY_LEVEL = "light_level"; + + private static AmbientLight sInstance = null; + private static Handler sHandler = null; + + private SQLiteDatabase mDatabase = null; + + private Sensor mSensor = null; + + public static AmbientLight getInstance(Context context) { + if (AmbientLight.sInstance == null) { + AmbientLight.sInstance = new AmbientLight(context.getApplicationContext()); + } + + return AmbientLight.sInstance; + } + + public AmbientLight(Context context) { + super(context); + } + + public static void start(final Context context) { + AmbientLight.getInstance(context).startGenerator(); + } + + private void startGenerator() { + final SensorManager sensors = (SensorManager) this.mContext.getSystemService(Context.SENSOR_SERVICE); + + final AmbientLight me = this; + + if (AmbientLight.isEnabled(this.mContext)) { + this.mSensor = sensors.getDefaultSensor(Sensor.TYPE_LIGHT); + + Runnable r = new Runnable() + { + public void run() + { + Looper.prepare(); + + AmbientLight.sHandler = new Handler(); + + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) + sensors.registerListener(me, me.mSensor, SensorManager.SENSOR_DELAY_NORMAL, 0, AmbientLight.sHandler); + else + sensors.registerListener(me, me.mSensor, SensorManager.SENSOR_DELAY_NORMAL, AmbientLight.sHandler); + + Looper.loop(); + } + }; + + Thread t = new Thread(r, "ambient-light"); + t.start(); + } else { + if (this.mSensor != null) { + if (AmbientLight.sHandler != null) { + Looper loop = AmbientLight.sHandler.getLooper(); + loop.quit(); + + AmbientLight.sHandler = null; + } + + sensors.unregisterListener(this, this.mSensor); + + this.mSensor = null; + } + } + + + Generators.getInstance(this.mContext).registerCustomViewClass(AmbientLight.GENERATOR_IDENTIFIER, Battery.class); + + File path = PassiveDataKit.getGeneratorsStorage(this.mContext); + + path = new File(path, AmbientLight.DATABASE_PATH); + + this.mDatabase = SQLiteDatabase.openOrCreateDatabase(path, null); + + int version = this.getDatabaseVersion(this.mDatabase); + + switch (version) { + case 0: +// +// this.mDatabase.execSQL(this.mContext.getString(R.string.pdk_generator_device_ambient_light_create_history_table)); + } + + this.setDatabaseVersion(this.mDatabase, AmbientLight.DATABASE_VERSION); + } + + public static boolean isEnabled(Context context) { + SharedPreferences prefs = Generators.getInstance(context).getSharedPreferences(context); + + return prefs.getBoolean(AmbientLight.ENABLED, AmbientLight.ENABLED_DEFAULT); + } + + public static boolean isRunning(Context context) { + if (AmbientLight.sInstance == null) { + return false; + } + + return AmbientLight.sInstance.mSensor != null; + } + + public static ArrayList diagnostics(Context context) { + return new ArrayList<>(); + } + + public static void bindViewHolder(DataPointViewHolder holder) { + final Context context = holder.itemView.getContext(); + + AmbientLight generator = AmbientLight.getInstance(context); + + long now = System.currentTimeMillis(); + long start = now - (24 * 60 * 60 * 1000); + + String where = AmbientLight.HISTORY_OBSERVED + " >= ?"; + String[] args = { "" + start }; + + Cursor c = generator.mDatabase.query(AmbientLight.TABLE_HISTORY, null, where, args, null, null, AmbientLight.HISTORY_OBSERVED + " DESC"); + + View cardContent = holder.itemView.findViewById(R.id.card_content); + View cardEmpty = holder.itemView.findViewById(R.id.card_empty); + TextView dateLabel = (TextView) holder.itemView.findViewById(R.id.generator_data_point_date); + + if (c.moveToNext()) { + cardContent.setVisibility(View.VISIBLE); + cardEmpty.setVisibility(View.GONE); + + long timestamp = c.getLong(c.getColumnIndex(AmbientLight.HISTORY_OBSERVED)) / 1000; + + dateLabel.setText(Generator.formatTimestamp(context, timestamp)); + + c.moveToPrevious(); + + final LineChart chart = (LineChart) holder.itemView.findViewById(R.id.battery_level_chart); + chart.setViewPortOffsets(0,0,0,0); + chart.setHighlightPerDragEnabled(false); + chart.setHighlightPerTapEnabled(false); + chart.setBackgroundColor(ContextCompat.getColor(context, android.R.color.black)); + chart.setPinchZoom(false); + + final DateFormat timeFormat = android.text.format.DateFormat.getTimeFormat(context); + + final XAxis xAxis = chart.getXAxis(); + xAxis.setPosition(XAxis.XAxisPosition.BOTTOM_INSIDE); + xAxis.setTextSize(10f); + xAxis.setDrawAxisLine(true); + xAxis.setDrawGridLines(true); + xAxis.setCenterAxisLabels(true); + xAxis.setDrawLabels(true); + xAxis.setTextColor(ContextCompat.getColor(context, android.R.color.white)); + xAxis.setGranularityEnabled(true); + xAxis.setGranularity(1); + xAxis.setAxisMinimum(start); + xAxis.setAxisMaximum(now); + xAxis.setValueFormatter(new IAxisValueFormatter() { + @Override + public String getFormattedValue(float value, AxisBase axis) { + Date date = new Date((long) value); + + return timeFormat.format(date); + } + }); + + YAxis leftAxis = chart.getAxisLeft(); + leftAxis.setPosition(YAxis.YAxisLabelPosition.INSIDE_CHART); + leftAxis.setDrawGridLines(true); + leftAxis.setDrawAxisLine(true); + leftAxis.setGranularityEnabled(true); + leftAxis.setAxisMaximum(110); + leftAxis.setAxisMinimum(-10); + leftAxis.setTextColor(ContextCompat.getColor(context, android.R.color.white)); + + YAxis rightAxis = chart.getAxisRight(); + rightAxis.setEnabled(false); + + chart.getLegend().setEnabled(false); + chart.getDescription().setEnabled(false); + + ArrayList values = new ArrayList<>(); + + long lastLevel = -1; + + while (c.moveToNext()) { + long when = c.getLong(c.getColumnIndex(AmbientLight.HISTORY_OBSERVED)); + long level = c.getLong(c.getColumnIndex(AmbientLight.HISTORY_LEVEL)); + + if (level != lastLevel) { + values.add(0, new Entry(when, level)); + lastLevel = level; + + Log.e("SLEEP-SIGHT", "VALUE: " + level + " -- " + (when - start)); + } + } + + Log.e("SLEEP-SIGHT", "LIGHT VALUES COUNT 2: " + values.size()); + + LineDataSet set = new LineDataSet(values, "Light Level"); + set.setAxisDependency(YAxis.AxisDependency.LEFT); + set.setLineWidth(2.0f); + set.setDrawCircles(false); + set.setFillAlpha(192); + set.setDrawFilled(false); + set.setDrawValues(true); + set.setColor(ContextCompat.getColor(context, R.color.generator_battery_plot)); + set.setDrawCircleHole(false); + set.setDrawValues(false); + set.setMode(LineDataSet.Mode.LINEAR); + + chart.setVisibleYRange(0, 120, YAxis.AxisDependency.LEFT); + chart.setData(new LineData(set)); + } else { + cardContent.setVisibility(View.GONE); + cardEmpty.setVisibility(View.VISIBLE); + + dateLabel.setText(R.string.label_never_pdk); + } + + c.close(); + } + + public static View fetchView(ViewGroup parent) + { + return LayoutInflater.from(parent.getContext()).inflate(R.layout.card_generator_device_battery, parent, false); + } + + @Override + public List fetchPayloads() { + return new ArrayList<>(); + } + + public static long latestPointGenerated(Context context) { + long timestamp = 0; + + AmbientLight me = AmbientLight.getInstance(context); + + Cursor c = me.mDatabase.query(AmbientLight.TABLE_HISTORY, null, null, null, null, null, AmbientLight.HISTORY_OBSERVED + " DESC"); + + if (c.moveToNext()) { + timestamp = c.getLong(c.getColumnIndex(AmbientLight.HISTORY_OBSERVED)); + } + + c.close(); + + return timestamp; + } + + public Cursor queryHistory(String[] cols, String where, String[] args, String orderBy) { + return this.mDatabase.query(AmbientLight.TABLE_HISTORY, cols, where, args, null, null, orderBy); + } + + @Override + public void onSensorChanged(SensorEvent sensorEvent) { + + } + + @Override + public void onAccuracyChanged(Sensor sensor, int newAccuracy) { + + } } diff --git a/src/com/audacious_software/passive_data_kit/generators/wearables/WithingsDevice.java b/src/com/audacious_software/passive_data_kit/generators/wearables/WithingsDevice.java index 7f47926..b56eeb9 100755 --- a/src/com/audacious_software/passive_data_kit/generators/wearables/WithingsDevice.java +++ b/src/com/audacious_software/passive_data_kit/generators/wearables/WithingsDevice.java @@ -13,11 +13,14 @@ import android.os.Handler; import android.os.Looper; import android.preference.PreferenceManager; +import android.support.v4.content.ContextCompat; +import android.support.v4.view.PagerAdapter; +import android.support.v4.view.ViewPager; import android.util.Base64; -import android.util.Log; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; +import android.widget.LinearLayout; import android.widget.TextView; import com.audacious_software.passive_data_kit.PassiveDataKit; @@ -27,8 +30,12 @@ import com.audacious_software.passive_data_kit.generators.Generators; import com.audacious_software.passive_data_kit.generators.diagnostics.AppEvent; import com.audacious_software.pdk.passivedatakit.R; +import com.github.mikephil.charting.charts.LineChart; import com.github.mikephil.charting.charts.PieChart; +import com.github.mikephil.charting.components.YAxis; import com.github.mikephil.charting.data.Entry; +import com.github.mikephil.charting.data.LineData; +import com.github.mikephil.charting.data.LineDataSet; import com.github.mikephil.charting.data.PieData; import com.github.mikephil.charting.data.PieDataSet; import com.github.mikephil.charting.data.PieEntry; @@ -49,8 +56,8 @@ import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; -import java.util.Date; import java.util.HashMap; +import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.StringTokenizer; @@ -71,6 +78,10 @@ public class WithingsDevice extends Generator { private static final String DATASTREAM = "datastream"; private static final String DATASTREAM_ACTIVITY_MEASURES = "activity-measures"; + private static final String DATASTREAM_INTRADAY_ACTIVITY = "intraday-activity"; + private static final String DATASTREAM_BODY = "body"; + private static final String DATASTREAM_SLEEP_MEASURES = "sleep-measures"; + private static final String DATASTREAM_SLEEP_SUMMARY = "sleep-summary"; private static final String TABLE_ACTIVITY_MEASURE_HISTORY = "activity_measure_history"; private static final String ACTIVITY_MEASURE_HISTORY_DATE_START = "date_start"; @@ -122,6 +133,14 @@ public class WithingsDevice extends Generator { private static final String BODY_MEASURE_HISTORY_VALUE = "measure_value"; private static final String TABLE_INTRADAY_ACTIVITY_HISTORY = "intraday_activity_history"; + private static final String INTRADAY_ACTIVITY_START = "activity_start"; + private static final String INTRADAY_ACTIVITY_DURATION = "activity_duration"; + private static final String INTRADAY_ACTIVITY_CALORIES = "calories"; + private static final String INTRADAY_ACTIVITY_DISTANCE = "distance"; + private static final String INTRADAY_ACTIVITY_ELEVATION_CLIMBED = "elevation_climbed"; + private static final String INTRADAY_ACTIVITY_STEPS = "steps"; + private static final String INTRADAY_ACTIVITY_SWIM_STROKES = "swim_strokes"; + private static final String INTRADAY_ACTIVITY_POOL_LAPS = "pool_laps"; private static final String TABLE_SLEEP_MEASURE_HISTORY = "sleep_measure_history"; private static final String SLEEP_MEASURE_MODEL_UNKNOWN = "unknown"; @@ -186,6 +205,9 @@ public class WithingsDevice extends Generator { private static final String WORKOUTS_ENABLED = "com.audacious_software.passive_data_kit.generators.wearables.WithingsDevice.WORKOUTS_ENABLED"; private static final boolean WORKOUTS_ENABLED_DEFAULT = true; + private static final String SERVER_FETCH_ENABLED = "com.audacious_software.passive_data_kit.generators.wearables.WithingsDevice.SERVER_FETCH_ENABLED"; + private static final boolean SERVER_FETCH_ENABLED_DEFAULT = false; + public static final String OPTION_OAUTH_CALLBACK_URL = "com.audacious_software.passive_data_kit.generators.wearables.WithingsDevice.OPTION_CALLBACK_URL"; public static final String OPTION_OAUTH_CONSUMER_KEY = "com.audacious_software.passive_data_kit.generators.wearables.WithingsDevice.OPTION_OAUTH_CONSUMER_KEY"; public static final String OPTION_OAUTH_CONSUMER_SECRET = "com.audacious_software.passive_data_kit.generators.wearables.WithingsDevice.OPTION_OAUTH_CONSUMER_SECRET"; @@ -202,12 +224,18 @@ public class WithingsDevice extends Generator { private static final String API_ACTION_WORKOUTS_URL = "https://wbsapi.withings.net/v2/measure?action=getworkouts"; public static final String API_OAUTH_CALLBACK_PATH = "/oauth/withings"; + private static final String OAUTH_CONSUMER_KEY = "oauth_consumer_key"; + private static final String OAUTH_USER_TOKEN = "oauth_user_token"; + private static final String OAUTH_USER_SECRET = "oauth_user_secret"; + private static WithingsDevice sInstance = null; private Context mContext = null; private SQLiteDatabase mDatabase = null; private Handler mHandler = null; private Map mProperties = new HashMap<>(); + private int mPage = 0; + public static WithingsDevice getInstance(Context context) { if (WithingsDevice.sInstance == null) { WithingsDevice.sInstance = new WithingsDevice(context.getApplicationContext()); @@ -248,51 +276,39 @@ private void startGenerator() { final Runnable fetchData = new Runnable() { @Override public void run() { - Log.e("PDK", "WITHINGS FETCH DATA"); - final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(me.mContext); long fetchInterval = prefs.getLong(WithingsDevice.DATA_FETCH_INTERVAL, WithingsDevice.DATA_FETCH_INTERVAL_DEFAULT); if (me.approvalGranted()) { - Log.e("PDK", "WITHINGS APPROVED"); - long lastFetch = prefs.getLong(WithingsDevice.LAST_DATA_FETCH, 0); long now = System.currentTimeMillis(); if (now - lastFetch > fetchInterval) { - Log.e("PDK", "TIME TO FETCH"); - Runnable r = new Runnable() { @Override public void run() { if (prefs.getBoolean(WithingsDevice.ACTIVITY_MEASURES_ENABLED, WithingsDevice.ACTIVITY_MEASURES_ENABLED_DEFAULT)) { - Log.e("SLEEP-SIGHT", "FETCH ACTIVITY MEASURES"); me.fetchActivityMeasures(); } if (prefs.getBoolean(WithingsDevice.BODY_MEASURES_ENABLED, WithingsDevice.BODY_MEASURES_ENABLED_DEFAULT)) { - Log.e("SLEEP-SIGHT", "FETCH BODY MEASURES"); me.fetchBodyMeasures(); } if (prefs.getBoolean(WithingsDevice.INTRADAY_ACTIVITY_ENABLED, WithingsDevice.INTRADAY_ACTIVITY_ENABLED_DEFAULT)) { - Log.e("SLEEP-SIGHT", "FETCH INTRADAY ACTIVITY"); me.fetchIntradayActivities(); } if (prefs.getBoolean(WithingsDevice.SLEEP_MEASURES_ENABLED, WithingsDevice.SLEEP_MEASURES_ENABLED_DEFAULT)) { - Log.e("SLEEP-SIGHT", "FETCH SLEEP MEASURES"); me.fetchSleepMeasures(); } if (prefs.getBoolean(WithingsDevice.SLEEP_SUMMARY_ENABLED, WithingsDevice.SLEEP_SUMMARY_ENABLED_DEFAULT)) { - Log.e("SLEEP-SIGHT", "FETCH SLEEP SUMMARY"); me.fetchSleepSummary(); } if (prefs.getBoolean(WithingsDevice.WORKOUTS_ENABLED, WithingsDevice.WORKOUTS_ENABLED_DEFAULT)) { - Log.e("SLEEP-SIGHT", "FETCH WORKOUTS"); me.fetchWorkouts(); } } @@ -304,11 +320,7 @@ public void run() { SharedPreferences.Editor e = prefs.edit(); e.putLong(WithingsDevice.LAST_DATA_FETCH, now); e.apply(); - } else { - Log.e("PDK", "NOT TIME TO FETCH"); } - } else { - Log.e("PDK", "WITHINGS NOT APPROVED"); } if (me.mHandler != null) { @@ -557,6 +569,8 @@ private void fetchActivityMeasures() { updated.putDouble(WithingsDevice.ACTIVITY_MEASURE_INTENSE_ACTIVITY_DURATION, activity.getDouble("intense")); updated.putString(WithingsDevice.DATASTREAM, WithingsDevice.DATASTREAM_ACTIVITY_MEASURES); + this.annotateGeneratorReading(updated); + Generators.getInstance(this.mContext).notifyGeneratorUpdated(WithingsDevice.GENERATOR_IDENTIFIER, updated); } } @@ -569,12 +583,6 @@ private void fetchActivityMeasures() { private void fetchBodyMeasures() { JSONObject response = this.queryApi(WithingsDevice.API_ACTION_BODY_MEASURES_URL); - try { - Log.e("SLEEP-SIGHT", "BODY JSON: " + response.toString(2)); - } catch (JSONException e) { - e.printStackTrace(); - } - if (response != null) { try { if (response.getInt("status") == 0) { @@ -700,6 +708,9 @@ private void fetchBodyMeasures() { updated.putString(WithingsDevice.BODY_MEASURE_HISTORY_CATEGORY, category); updated.putString(WithingsDevice.BODY_MEASURE_HISTORY_TYPE, type); updated.putDouble(WithingsDevice.BODY_MEASURE_HISTORY_VALUE, value); + updated.putString(WithingsDevice.DATASTREAM, WithingsDevice.DATASTREAM_BODY); + + this.annotateGeneratorReading(updated); Generators.getInstance(this.mContext).notifyGeneratorUpdated(WithingsDevice.GENERATOR_IDENTIFIER, updated); } @@ -715,19 +726,90 @@ private void fetchIntradayActivities() { JSONObject response = this.queryApi(WithingsDevice.API_ACTION_INTRADAY_ACTIVITY_URL); if (response != null) { - // TODO + try { + long now = System.currentTimeMillis(); + + if (response.getInt("status") == 0) { + JSONObject body = response.getJSONObject("body"); + + JSONObject series = body.getJSONObject("series"); + + Iterator keys = series.keys(); + + while (keys.hasNext()) { + String key = keys.next(); + + long timestamp = Long.parseLong(key); + + String where = WithingsDevice.INTRADAY_ACTIVITY_START + " = ?"; + String[] args = { "" + timestamp }; + + Cursor c = this.mDatabase.query(WithingsDevice.TABLE_INTRADAY_ACTIVITY_HISTORY, null, where, args, null, null, WithingsDevice.HISTORY_OBSERVED + " DESC"); + + if (c.moveToNext() == false) { + JSONObject item = series.getJSONObject(key); + + ContentValues values = new ContentValues(); + values.put(WithingsDevice.HISTORY_OBSERVED, now); + values.put(WithingsDevice.INTRADAY_ACTIVITY_START, timestamp); + values.put(WithingsDevice.INTRADAY_ACTIVITY_DURATION, item.getLong("duration")); + + Bundle updated = new Bundle(); + updated.putLong(WithingsDevice.HISTORY_OBSERVED, System.currentTimeMillis()); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_START, timestamp); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_DURATION, item.getLong("duration")); + + if (item.has("steps")) { + values.put(WithingsDevice.INTRADAY_ACTIVITY_STEPS, item.getLong("steps")); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_STEPS, item.getLong("steps")); + } + + if (item.has("elevation")) { + values.put(WithingsDevice.INTRADAY_ACTIVITY_ELEVATION_CLIMBED, item.getLong("elevation")); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_ELEVATION_CLIMBED, item.getLong("elevation")); + } + + if (item.has("distance")) { + values.put(WithingsDevice.INTRADAY_ACTIVITY_DISTANCE, item.getLong("distance")); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_DISTANCE, item.getLong("distance")); + } + + if (item.has("calories")) { + values.put(WithingsDevice.INTRADAY_ACTIVITY_CALORIES, item.getLong("calories")); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_CALORIES, item.getLong("calories")); + } + + if (item.has("stroke")) { + values.put(WithingsDevice.INTRADAY_ACTIVITY_SWIM_STROKES, item.getLong("stroke")); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_SWIM_STROKES, item.getLong("stroke")); + } + + if (item.has("pool_lap")) { + values.put(WithingsDevice.INTRADAY_ACTIVITY_POOL_LAPS, item.getLong("pool_lap")); + updated.putLong(WithingsDevice.INTRADAY_ACTIVITY_POOL_LAPS, item.getLong("pool_lap")); + } + + this.mDatabase.insert(WithingsDevice.TABLE_INTRADAY_ACTIVITY_HISTORY, null, values); + + this.annotateGeneratorReading(updated); + + updated.putString(WithingsDevice.DATASTREAM, WithingsDevice.DATASTREAM_INTRADAY_ACTIVITY); + + Generators.getInstance(this.mContext).notifyGeneratorUpdated(WithingsDevice.GENERATOR_IDENTIFIER, updated); + } + + c.close(); + } + } + } catch (JSONException e) { + e.printStackTrace(); + } } } private void fetchSleepMeasures() { JSONObject response = this.queryApi(WithingsDevice.API_ACTION_SLEEP_MEASURES_URL); - try { - Log.e("SLEEP-SIGHT", "SLEEP JSON: " + response.toString(2)); - } catch (JSONException e) { - e.printStackTrace(); - } - if (response != null) { try { if (response.getInt("status") == 0) { @@ -784,6 +866,10 @@ private void fetchSleepMeasures() { updated.putString(WithingsDevice.SLEEP_MEASURE_STATE, state); updated.putString(WithingsDevice.SLEEP_MEASURE_MEASUREMENT_DEVICE, model); + this.annotateGeneratorReading(updated); + + updated.putString(WithingsDevice.DATASTREAM, WithingsDevice.DATASTREAM_SLEEP_MEASURES); + Generators.getInstance(this.mContext).notifyGeneratorUpdated(WithingsDevice.GENERATOR_IDENTIFIER, updated); } } @@ -796,12 +882,6 @@ private void fetchSleepMeasures() { private void fetchSleepSummary() { JSONObject response = this.queryApi(WithingsDevice.API_ACTION_SLEEP_SUMMARY_URL); - try { - Log.e("SLEEP-SIGHT", "SLEEP SUMMARY JSON: " + response.toString(2)); - } catch (JSONException e) { - e.printStackTrace(); - } - if (response != null) { try { if (response.getInt("status") == 0) { @@ -871,6 +951,10 @@ private void fetchSleepSummary() { updated.putDouble(WithingsDevice.SLEEP_SUMMARY_TO_WAKE_DURATION, data.getDouble("durationtowakeup")); } + this.annotateGeneratorReading(updated); + + updated.putString(WithingsDevice.DATASTREAM, WithingsDevice.DATASTREAM_SLEEP_SUMMARY); + Generators.getInstance(this.mContext).notifyGeneratorUpdated(WithingsDevice.GENERATOR_IDENTIFIER, updated); } } @@ -880,6 +964,20 @@ private void fetchSleepSummary() { } } + private void annotateGeneratorReading(Bundle reading) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + + if (prefs.getBoolean(WithingsDevice.SERVER_FETCH_ENABLED, WithingsDevice.SERVER_FETCH_ENABLED_DEFAULT)) { + String apiKey = this.getProperty(WithingsDevice.OPTION_OAUTH_CONSUMER_KEY); + String token = this.getProperty(WithingsDevice.OPTION_OAUTH_ACCESS_TOKEN); + String tokenSecret = this.getProperty(WithingsDevice.OPTION_OAUTH_ACCESS_TOKEN_SECRET); + + reading.putString(WithingsDevice.OAUTH_CONSUMER_KEY, apiKey); + reading.putString(WithingsDevice.OAUTH_USER_TOKEN, token); + reading.putString(WithingsDevice.OAUTH_USER_SECRET, tokenSecret); + } + } + private void fetchWorkouts() { JSONObject response = this.queryApi(WithingsDevice.API_ACTION_WORKOUTS_URL); @@ -1141,10 +1239,94 @@ public void run() { t.start(); } - public static void bindViewHolder(DataPointViewHolder holder) { - final Context context = holder.itemView.getContext(); + public static void bindViewHolder(final DataPointViewHolder holder) { + final WithingsDevice withings = WithingsDevice.getInstance(holder.itemView.getContext()); + + ViewPager pager = (ViewPager) holder.itemView.findViewById(R.id.content_pager); + + PagerAdapter adapter = new PagerAdapter() { + @Override + public int getCount() { + return 7; + } + + @Override + public boolean isViewFromObject(View view, Object content) { + return view.getTag().equals(content); + } + + public void destroyItem(ViewGroup container, int position, Object content) { + int toRemove = -1; + + for (int i = 0; i < container.getChildCount(); i++) { + View child = container.getChildAt(i); + + if (this.isViewFromObject(child, content)) + toRemove = i; + } + + if (toRemove >= 0) + container.removeViewAt(toRemove); + } + + public Object instantiateItem(ViewGroup container, int position) { + switch (position) { + case 0: + return WithingsDevice.bindActivityPage(container, holder, position); + case 1: + return WithingsDevice.bindIntradayPage(container, holder, position); + case 2: + return WithingsDevice.bindBodyPage(container, holder, position); + case 3: + return WithingsDevice.bindSleepPage(container, holder, position); + case 4: + return WithingsDevice.bindSleepSummaryPage(container, holder, position); + case 5: + return WithingsDevice.bindWorkoutsPage(container, holder, position); + default: + return WithingsDevice.bindInformationPage(container, holder, position); + } + } + }; + + pager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() { + @Override + public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { + + } + + @Override + public void onPageSelected(int position) { + withings.mPage = position; + } + + @Override + public void onPageScrollStateChanged(int state) { + + } + }); + + pager.setAdapter(adapter); + + pager.setCurrentItem(withings.mPage); + } + + private static String bindInformationPage(ViewGroup container, DataPointViewHolder holder, int position) { + final Context context = container.getContext(); + + LinearLayout card = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.card_generator_withings_info_page, null); + card.setTag("" + position); + + container.addView(card); + + return "" + card.getTag(); + } + + private static String bindActivityPage(ViewGroup container, DataPointViewHolder holder, int position) { + final Context context = container.getContext(); - SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); + LinearLayout card = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.card_generator_withings_activity_page, null); + card.setTag("" + position); long lastTimestamp = 0; @@ -1156,7 +1338,7 @@ public static void bindViewHolder(DataPointViewHolder holder) { double moderateActivity = 0; double intenseActivity = 0; - WithingsDevice generator = WithingsDevice.getInstance(holder.itemView.getContext()); + WithingsDevice generator = WithingsDevice.getInstance(card.getContext()); Cursor c = generator.mDatabase.query(WithingsDevice.TABLE_ACTIVITY_MEASURE_HISTORY, null, null, null, null, null, WithingsDevice.HISTORY_OBSERVED + " DESC"); @@ -1176,8 +1358,8 @@ public static void bindViewHolder(DataPointViewHolder holder) { c.close(); - View cardContent = holder.itemView.findViewById(R.id.card_content); - View cardEmpty = holder.itemView.findViewById(R.id.card_empty); + View cardContent = card.findViewById(R.id.content_activity); + View cardEmpty = card.findViewById(R.id.card_empty); TextView dateLabel = (TextView) holder.itemView.findViewById(R.id.generator_data_point_date); if (lastTimestamp > 0) { @@ -1186,7 +1368,7 @@ public static void bindViewHolder(DataPointViewHolder holder) { dateLabel.setText(Generator.formatTimestamp(context, lastTimestamp)); - PieChart pieChart = (PieChart) holder.itemView.findViewById(R.id.chart_phone_calls); + PieChart pieChart = (PieChart) card.findViewById(R.id.chart_phone_calls); pieChart.getLegend().setEnabled(false); pieChart.setEntryLabelColor(android.R.color.transparent); @@ -1234,13 +1416,13 @@ public String getFormattedValue(float value, Entry entry, int dataSetIndex, View dateLabel.setText(Generator.formatTimestamp(context, lastTimestamp / 1000)); - TextView stepsValue = (TextView) holder.itemView.findViewById(R.id.field_steps); + TextView stepsValue = (TextView) card.findViewById(R.id.field_steps); stepsValue.setText(context.getString(R.string.generator_withings_steps_value, (int) steps)); - TextView distanceValue = (TextView) holder.itemView.findViewById(R.id.field_distance); + TextView distanceValue = (TextView) card.findViewById(R.id.field_distance); distanceValue.setText(context.getString(R.string.generator_withings_distance_value, (distance / 1000))); - TextView elevationValue = (TextView) holder.itemView.findViewById(R.id.field_elevation); + TextView elevationValue = (TextView) card.findViewById(R.id.field_elevation); elevationValue.setText(context.getString(R.string.generator_withings_elevation_value, elevation)); } else { cardContent.setVisibility(View.GONE); @@ -1248,6 +1430,10 @@ public String getFormattedValue(float value, Entry entry, int dataSetIndex, View dateLabel.setText(R.string.label_never_pdk); } + + container.addView(card); + + return "" + card.getTag(); } @Override @@ -1295,4 +1481,278 @@ public void setProperty(String key, String value) { this.mProperties.put(key, value); } + + private static String bindIntradayPage(ViewGroup container, DataPointViewHolder holder, int position) { + final Context context = container.getContext(); + + long now = System.currentTimeMillis(); + + WithingsDevice withings = WithingsDevice.getInstance(context); + + LinearLayout card = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.card_generator_withings_intraday_page, null); + card.setTag("" + position); + + LineChart stepsChart = (LineChart) card.findViewById(R.id.chart_steps); + LineChart distanceChart = (LineChart) card.findViewById(R.id.chart_distance); + LineChart elevationChart = (LineChart) card.findViewById(R.id.chart_elevation); + LineChart caloriesChart = (LineChart) card.findViewById(R.id.chart_calories); + + ArrayList steps = new ArrayList<>(); + ArrayList distance = new ArrayList<>(); + ArrayList elevation = new ArrayList<>(); + ArrayList calories = new ArrayList<>(); + + float stepSum = 0; + float distanceSum = 0; + float elevationSum = 0; + float caloriesSum = 0; + + Calendar cal = Calendar.getInstance(); + cal.set(Calendar.HOUR_OF_DAY, 0); + cal.set(Calendar.MINUTE, 0); + cal.set(Calendar.SECOND, 0); + cal.set(Calendar.MILLISECOND, 0); + + long start = cal.getTimeInMillis() / 1000; + + cal.add(Calendar.DATE, 1); + + long end = cal.getTimeInMillis() / 1000; + + String where = WithingsDevice.INTRADAY_ACTIVITY_START + " > ?"; + String[] args = { "" + start }; + + Cursor c = withings.mDatabase.query(WithingsDevice.TABLE_INTRADAY_ACTIVITY_HISTORY, null, where, args, null, null, WithingsDevice.INTRADAY_ACTIVITY_START); + + steps.add(new Entry(0, 0)); + distance.add(new Entry(0, 0)); + elevation.add(new Entry(0, 0)); + calories.add(new Entry(0, 0)); + + while (c.moveToNext()) { + long when = c.getLong(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_START)); + + if (c.isNull(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_STEPS)) == false) { + float value = c.getFloat(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_STEPS)); + + stepSum += value; + + steps.add(new Entry(when - start, stepSum)); + } + + if (c.isNull(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_DISTANCE)) == false) { + float value = c.getFloat(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_DISTANCE)); + + distanceSum += value; + + distance.add(new Entry(when - start, distanceSum)); + } + + if (c.isNull(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_ELEVATION_CLIMBED)) == false) { + float value = c.getFloat(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_ELEVATION_CLIMBED)); + + elevationSum += value; + + elevation.add(new Entry(when - start, elevationSum)); + } + + if (c.isNull(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_CALORIES)) == false) { + float value = c.getFloat(c.getColumnIndex(WithingsDevice.INTRADAY_ACTIVITY_CALORIES)); + + caloriesSum += value; + + calories.add(new Entry(when - start, caloriesSum)); + } + } + + steps.add(new Entry((now / 1000) - start, stepSum)); + distance.add(new Entry((now / 1000) - start, distanceSum)); + elevation.add(new Entry((now / 1000) - start, elevationSum)); + calories.add(new Entry((now / 1000) - start, caloriesSum)); + + WithingsDevice.populateIntradayChart(context, stepsChart, steps, 0, end - start); + WithingsDevice.populateIntradayChart(context, distanceChart, distance, 0, end - start); + WithingsDevice.populateIntradayChart(context, elevationChart, elevation, 0, end - start); + WithingsDevice.populateIntradayChart(context, caloriesChart, calories, 0, end - start); + + c.close(); + + container.addView(card); + + return "" + card.getTag(); + } + + private static void populateIntradayChart(Context context, LineChart chart, ArrayList values, long start, long end) { + chart.getLegend().setEnabled(false); + chart.getAxisRight().setEnabled(false); + chart.getDescription().setEnabled(false); + + LineData data = new LineData(); + + LineDataSet set = new LineDataSet(values, ""); + set.setAxisDependency(YAxis.AxisDependency.LEFT); + set.setLineWidth(1.0f); + set.setDrawCircles(false); + set.setFillAlpha(128); + set.setDrawFilled(true); + set.setDrawValues(false); + set.setColor(ContextCompat.getColor(context, R.color.generator_battery_plot)); + set.setFillColor(ContextCompat.getColor(context, R.color.generator_battery_plot)); + + data.addDataSet(set); + + float minimum = (float) (0 - (values.get(values.size() - 1).getY() * 0.05)); + float maximum = (float) (values.get(values.size() - 1).getY() * 1.25); + + if (minimum == 0) { + minimum = -0.05f; + maximum = 0.95f; + } + + chart.getAxisLeft().setAxisMinimum(minimum); + chart.getAxisLeft().setAxisMaximum(maximum); + chart.getAxisLeft().setDrawGridLines(false); + chart.getAxisLeft().setPosition(YAxis.YAxisLabelPosition.INSIDE_CHART); + chart.getAxisLeft().setDrawAxisLine(false); + chart.getAxisLeft().setDrawLabels(false); + chart.getAxisLeft().setTextColor(ContextCompat.getColor(context, android.R.color.white)); + + chart.getXAxis().setAxisMinimum(start); + chart.getXAxis().setAxisMaximum(end); + chart.getXAxis().setDrawGridLines(false); + chart.getXAxis().setDrawLabels(false); + chart.getXAxis().setDrawAxisLine(false); + + chart.setViewPortOffsets(0,0,8,0); + chart.setHighlightPerDragEnabled(false); + chart.setHighlightPerTapEnabled(false); + chart.setBackgroundColor(ContextCompat.getColor(context, android.R.color.black)); + chart.setPinchZoom(false); + + ArrayList lastValue = new ArrayList<>(); + lastValue.add(values.get(values.size() - 1)); + + LineDataSet lastItem = new LineDataSet(lastValue, ""); + lastItem.setAxisDependency(YAxis.AxisDependency.LEFT); + lastItem.setLineWidth(1.0f); + lastItem.setCircleRadius(3.0f); + lastItem.setCircleHoleRadius(2.0f); + lastItem.setDrawCircles(true); + lastItem.setValueTextSize(10f); + lastItem.setDrawValues(true); + lastItem.setCircleColor(ContextCompat.getColor(context, R.color.generator_battery_plot)); + lastItem.setCircleColorHole(ContextCompat.getColor(context, android.R.color.black)); + lastItem.setValueTextColor(ContextCompat.getColor(context, android.R.color.white)); + + data.addDataSet(lastItem); + + chart.setData(data); + } + + private static String bindBodyPage(ViewGroup container, DataPointViewHolder holder, int position) { + final Context context = container.getContext(); + + LinearLayout card = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.card_generator_withings_body_page, null); + card.setTag("" + position); + + container.addView(card); + + return "" + card.getTag(); + } + + private static String bindSleepPage(ViewGroup container, DataPointViewHolder holder, int position) { + final Context context = container.getContext(); + + LinearLayout card = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.card_generator_withings_sleep_page, null); + card.setTag("" + position); + + container.addView(card); + + return "" + card.getTag(); + } + + private static String bindSleepSummaryPage(ViewGroup container, DataPointViewHolder holder, int position) { + final Context context = container.getContext(); + + LinearLayout card = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.card_generator_withings_sleep_summary_page, null); + card.setTag("" + position); + + container.addView(card); + + return "" + card.getTag(); + } + + private static String bindWorkoutsPage(ViewGroup container, DataPointViewHolder holder, int position) { + final Context context = container.getContext(); + + LinearLayout card = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.card_generator_withings_workouts_page, null); + card.setTag("" + position); + + container.addView(card); + + return "" + card.getTag(); + } + + public void enableActivityMeasures(boolean enable) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + SharedPreferences.Editor e = prefs.edit(); + + e.putBoolean(WithingsDevice.ACTIVITY_MEASURES_ENABLED, enable); + + e.commit(); + } + + public void enableBodyMeasures(boolean enable) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + SharedPreferences.Editor e = prefs.edit(); + + e.putBoolean(WithingsDevice.BODY_MEASURES_ENABLED, enable); + + e.commit(); + } + + public void enableIntradayActivity(boolean enable) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + SharedPreferences.Editor e = prefs.edit(); + + e.putBoolean(WithingsDevice.INTRADAY_ACTIVITY_ENABLED, enable); + + e.commit(); + } + + public void enableSleepMeasures(boolean enable) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + SharedPreferences.Editor e = prefs.edit(); + + e.putBoolean(WithingsDevice.SLEEP_MEASURES_ENABLED, enable); + + e.commit(); + } + + public void enableSleepSummary(boolean enable) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + SharedPreferences.Editor e = prefs.edit(); + + e.putBoolean(WithingsDevice.SLEEP_SUMMARY_ENABLED, enable); + + e.commit(); + } + + public void enableWorkouts(boolean enable) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + SharedPreferences.Editor e = prefs.edit(); + + e.putBoolean(WithingsDevice.WORKOUTS_ENABLED, enable); + + e.commit(); + } + + public void enableServerFetch(boolean enable) { + SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.mContext); + SharedPreferences.Editor e = prefs.edit(); + + e.putBoolean(WithingsDevice.SERVER_FETCH_ENABLED, enable); + + e.commit(); + } } diff --git a/src/com/audacious_software/passive_data_kit/transmitters/HttpTransmitter.java b/src/com/audacious_software/passive_data_kit/transmitters/HttpTransmitter.java index 1d9a2cb..ed939ea 100755 --- a/src/com/audacious_software/passive_data_kit/transmitters/HttpTransmitter.java +++ b/src/com/audacious_software/passive_data_kit/transmitters/HttpTransmitter.java @@ -44,7 +44,6 @@ import okhttp3.Request; import okhttp3.RequestBody; import okhttp3.Response; -import okio.Buffer; public class HttpTransmitter extends Transmitter implements Generators.GeneratorUpdatedListener { public static final String UPLOAD_URI = "com.audacious_software.passive_data_kit.transmitters.HttpTransmitter.UPLOAD_URI"; @@ -159,6 +158,8 @@ private boolean shouldAttemptUpload(boolean force) { public void transmit(boolean force) { long now = System.currentTimeMillis(); + Log.e("PDK", "TRANSMIT: " + force); + if (force) { this.mLastAttempt = 0; }