From b04b7d043a8746af122f67f0b4d51a6a1417e75d Mon Sep 17 00:00:00 2001 From: wushunlian Date: Thu, 13 Jun 2019 14:45:25 +0800 Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=97=B6=E9=92=9F=E8=AF=A6?= =?UTF-8?q?=E7=BB=86=E8=AE=BE=E7=BD=AE=E7=95=8C=E9=9D=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/build.gradle | 7 +- .../socoolby/com/clock/MainActivity.java | 78 +- .../socoolby/com/clock/ThemeUIManager.java | 115 ++- .../fragment/AbstractThemeUIFragment.java | 670 ++++++++++++++++++ .../com/clock/fragment/AlterFragment.java | 57 +- .../fragment/DigitClockConfigFragment.java | 352 +++++++++ .../clock/fragment/DigitClockFragment.java | 2 +- .../fragment/SimulateClockConfigFragment.java | 239 +++++++ .../clock/fragment/SimulateClockFragment.java | 49 +- .../fragment/ThemeUIDefaultFragment.java | 18 + .../clock/fragment/ThemeUISampleFragment.java | 17 + .../com/clock/model/SharePerferenceModel.java | 119 +++- .../com/clock/state/ClockStateMachine.java | 129 +++- .../com/clock/viewmodel/AlterViewModel.java | 7 +- .../com/clock/viewmodel/DigitViewModel.java | 5 +- .../com/clock/viewmodel/GlobalViewModel.java | 16 +- .../clock/viewmodel/SimulateViewModel.java | 85 +++ .../animatorview/animator/ClockAnimator.java | 74 +- .../animator/clockanimator/AbstractClock.java | 75 +- .../animator/clockanimator/ClockFactory.java | 22 + .../animator/clockanimator/I_Pointer.java | 4 + .../SimulateTextShowTypeEnum.java | 22 + .../animator/clockanimator/SquareClock.java | 1 - .../pointer/AbstractPointer.java | 5 + .../widget/textview/AutoScrollTextView.java | 3 + .../clock/widget/textview/DigitTextView.java | 254 ++----- app/src/main/res/layout/activity_main.xml | 6 + app/src/main/res/layout/fragment_alter.xml | 3 +- .../main/res/layout/fragment_digit_config.xml | 225 ++++++ .../res/layout/fragment_simulate_config.xml | 167 +++++ build.gradle | 2 +- 31 files changed, 2415 insertions(+), 413 deletions(-) create mode 100644 app/src/main/java/clock/socoolby/com/clock/fragment/AbstractThemeUIFragment.java create mode 100644 app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockConfigFragment.java create mode 100644 app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockConfigFragment.java create mode 100644 app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUIDefaultFragment.java create mode 100644 app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUISampleFragment.java create mode 100644 app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/SimulateTextShowTypeEnum.java create mode 100644 app/src/main/res/layout/fragment_digit_config.xml create mode 100644 app/src/main/res/layout/fragment_simulate_config.xml diff --git a/app/build.gradle b/app/build.gradle index f49831a..440cdd5 100755 --- a/app/build.gradle +++ b/app/build.gradle @@ -20,8 +20,8 @@ android { productFlavors { } compileOptions { - sourceCompatibility = '1.7' - targetCompatibility = '1.7' + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 } packagingOptions { exclude 'META-INF/DEPENDENCIES' @@ -67,4 +67,7 @@ dependencies { implementation 'org.sqldroid:sqldroid:1.1.0-rc1' implementation "com.github.DeweyReed:UltimateMusicPicker:2.0.4" + + implementation 'com.jakewharton:butterknife:10.1.0' + annotationProcessor 'com.jakewharton:butterknife-compiler:10.1.0' } diff --git a/app/src/main/java/clock/socoolby/com/clock/MainActivity.java b/app/src/main/java/clock/socoolby/com/clock/MainActivity.java index 76041df..c555edc 100755 --- a/app/src/main/java/clock/socoolby/com/clock/MainActivity.java +++ b/app/src/main/java/clock/socoolby/com/clock/MainActivity.java @@ -40,10 +40,16 @@ import java.util.List; import clock.socoolby.com.clock.alter.AlterManager; import clock.socoolby.com.clock.dao.base.TimeFontStyle; +import clock.socoolby.com.clock.fragment.AlterFragment; +import clock.socoolby.com.clock.fragment.DigitClockConfigFragment; import clock.socoolby.com.clock.fragment.DigitClockFragment; +import clock.socoolby.com.clock.fragment.SimulateClockConfigFragment; import clock.socoolby.com.clock.fragment.SimulateClockFragment; +import clock.socoolby.com.clock.fragment.ThemeUIDefaultFragment; +import clock.socoolby.com.clock.fragment.ThemeUISampleFragment; import clock.socoolby.com.clock.protocol.WeatherResponse; import clock.socoolby.com.clock.service.ProximityService; +import clock.socoolby.com.clock.state.ClockModeEnum; import clock.socoolby.com.clock.state.ClockStateMachine; import clock.socoolby.com.clock.state.ClockTimeTypeEnum; import clock.socoolby.com.clock.model.SharePerferenceModel; @@ -68,6 +74,7 @@ import clock.socoolby.com.clock.widget.animatorview.animator.PhaserBallAnimator; import clock.socoolby.com.clock.widget.animatorview.animator.SawtoothAnimator; import clock.socoolby.com.clock.widget.animatorview.animator.Wave3DAnimator; import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.CircleTwoClock; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.ClockFactory; import clock.socoolby.com.clock.widget.animatorview.animator.textanimator.EZLedAnimator; import clock.socoolby.com.clock.widget.animatorview.animator.FireAnimator; import clock.socoolby.com.clock.widget.animatorview.animator.FireworkAnimator; @@ -115,7 +122,7 @@ public class MainActivity extends AppCompatActivity implements android.view.Ges private PowerManager.WakeLock localWakeLock = null; - WeatherResponse weatherAdape; + public WeatherResponse weatherAdape; private ClockTimeTypeEnum showTimeType=ClockTimeTypeEnum.TIME; @@ -132,7 +139,7 @@ public class MainActivity extends AppCompatActivity implements android.view.Ges AlterManager alterManager; - ThemeUIManager themeUIManager; + //ThemeUIManager themeUIManager; public void setWeather(WeatherResponse weather) { if (weather == null) @@ -238,13 +245,13 @@ public class MainActivity extends AppCompatActivity implements android.view.Ges themeUIViewModel=ViewModelProviders.of(MainActivity.this, viewModelFactory).get(ThemeUIViewModel.class); alterViewModel=ViewModelProviders.of(MainActivity.this, viewModelFactory).get(AlterViewModel.class); - clockStateMachine=new ClockStateMachine(alterManager,globalViewModel,digitViewModel,simulateViewModel,themeUIViewModel); + clockStateMachine=new ClockStateMachine(alterManager,globalViewModel,digitViewModel,simulateViewModel,themeUIViewModel,alterViewModel); setUpProximityService(); bindViewModel(); - themeUIManager=new ThemeUIManager(this,globalViewModel,digitViewModel,simulateViewModel,themeUIViewModel); + //themeUIManager=new ThemeUIManager(this,globalViewModel,digitViewModel,simulateViewModel,themeUIViewModel); digitViewModel.getTimeFontStyle().setValue(fontManager.getCurrentFontStyle()); @@ -267,6 +274,33 @@ public class MainActivity extends AppCompatActivity implements android.view.Ges } }); + globalViewModel.getClockModeEnum().observe(this, new Observer() { + @Override + public void onChanged(ClockModeEnum clockModeEnum) { + switch(clockModeEnum){ + case HANDUP: + getSupportFragmentManager().beginTransaction().replace(R.id.fragment_container, new AlterFragment(clockStateMachine)).commit(); + break; + default: + globalViewModel.getClockInterfaceTypeEnum().setValue(globalViewModel.getClockInterfaceTypeEnum().getValue()); + }; + } + }); + + themeUIViewModel.getThemeName().observe(this, new Observer() { + @Override + public void onChanged(String s) { + switch (s){ + case ThemeUISampleFragment.THEME_NAME: + getSupportFragmentManager().beginTransaction().replace(R.id.fragment_config_container, new ThemeUISampleFragment()).commit(); + break; + default: + getSupportFragmentManager().beginTransaction().replace(R.id.fragment_config_container, new ThemeUIDefaultFragment()).commit(); + } + } + }); + + globalViewModel.getBackgroundImageVisable().observe(this, new Observer() { @Override public void onChanged(Boolean visible) { @@ -887,7 +921,7 @@ public class MainActivity extends AppCompatActivity implements android.view.Ges if (e2.getX() - e1.getX() > 120) { // 从左向右滑动（左进右出） Log.d(TAG,"left->right"); if(globalViewModel.getClockInterfaceTypeEnum().getValue()== ClockInterfaceTypeEnum.Simulate){ - simulateViewModel.setClockTypeName(CircleTwoClock.TYPE_CIRCLE_TWO); + simulateViewModel.setClockTypeName(ClockFactory.nextSimulateClockName(simulateViewModel.getClockTypeName().getValue())); return true; } digitViewModel.setTimeFontStyle(fontManager.nextFont()); @@ -900,21 +934,35 @@ public class MainActivity extends AppCompatActivity implements android.view.Ges } + @Override public boolean onSingleTapConfirmed(MotionEvent e) { return false; } + boolean isShowAdvConfig=false; + @Override public boolean onDoubleTap(MotionEvent e) { - /*if(!isArtificialHiddle) { - tv_time.setLinearGradientRandom(!tv_time.isLinearGradientAble()); - return true; - }else if(clockAnimator!=null){ - clockAnimator.randPointer(); - return true; - }*/ - return false; + if(globalViewModel.getClockModeEnum().getValue()!=ClockModeEnum.NORMAL) + return false; + switch (globalViewModel.getClockInterfaceTypeEnum().getValue()){ + case Digit: + if(!isShowAdvConfig) + getSupportFragmentManager().beginTransaction().replace(R.id.fragment_config_container, new DigitClockConfigFragment()).addToBackStack(null).commit(); + else + getSupportFragmentManager().popBackStack(); + isShowAdvConfig=!isShowAdvConfig; + break; + case Simulate: + if(!isShowAdvConfig) + getSupportFragmentManager().beginTransaction().replace(R.id.fragment_config_container, new SimulateClockConfigFragment()).addToBackStack(null).commit(); + else + getSupportFragmentManager().popBackStack(); + isShowAdvConfig=!isShowAdvConfig; + break; + } + return true; } @Override @@ -994,4 +1042,8 @@ public class MainActivity extends AppCompatActivity implements android.view.Ges String result = numberFormat.format((float) num1 / (float) num2 * 100); return result+"%"; } + + public ClockStateMachine getClockStateMachine() { + return clockStateMachine; + } } diff --git a/app/src/main/java/clock/socoolby/com/clock/ThemeUIManager.java b/app/src/main/java/clock/socoolby/com/clock/ThemeUIManager.java index 82880a9..051897a 100644 --- a/app/src/main/java/clock/socoolby/com/clock/ThemeUIManager.java +++ b/app/src/main/java/clock/socoolby/com/clock/ThemeUIManager.java @@ -16,13 +16,16 @@ import java.util.Timer; import java.util.TimerTask; import clock.socoolby.com.clock.dao.base.TimeFontStyle; +import clock.socoolby.com.clock.model.DateModel; import clock.socoolby.com.clock.model.SharePerferenceModel; import clock.socoolby.com.clock.pop.CalendarPopup; import clock.socoolby.com.clock.pop.ColorPickerPop; import clock.socoolby.com.clock.pop.TimeSetupPopup; import clock.socoolby.com.clock.pop.WeatherPopup; import clock.socoolby.com.clock.state.ClockInterfaceTypeEnum; +import clock.socoolby.com.clock.state.ClockStateMachine; import clock.socoolby.com.clock.state.ClockThemeUITypeEnum; +import clock.socoolby.com.clock.state.ClockTimeTypeEnum; import clock.socoolby.com.clock.utils.FontUtils; import clock.socoolby.com.clock.viewmodel.DigitViewModel; import clock.socoolby.com.clock.viewmodel.GlobalViewModel; @@ -77,13 +80,14 @@ public class ThemeUIManager implements View.OnClickListener { private boolean autoFullScreen=false; - private int runDelaySecond=10000; private boolean running=false; Timer timer=null; + ClockStateMachine clockStateMachine; + private void autoFullScreenCheck(){ if(!autoFullScreen) return; @@ -112,6 +116,7 @@ public class ThemeUIManager implements View.OnClickListener { this.mainActivity = mainActivity; this.model = ClockApplication.getInstance().getModel(); + this.clockStateMachine=mainActivity.getClockStateMachine(); bindViewModel(); } @@ -159,6 +164,28 @@ public class ThemeUIManager implements View.OnClickListener { } }); + globalViewModel.getHandUpAble().observe(mainActivity, new Observer() { + @Override + public void onChanged(Boolean handUpAbla) { + if(handUpAbla) { + tv_handup.setColorFilter(globalViewModel.getForegroundColor().getValue()); + tv_hand_time.setVisibility(View.VISIBLE); + }else{ + tv_handup.setColorFilter(R.color.colorPrimaryDark); + tv_hand_time.setVisibility(View.GONE); + if(clockStateMachine.getCurrentShowTimeType()== ClockTimeTypeEnum.COUNTING_DOWN) + clockStateMachine.setCurrentShowTimeType(ClockTimeTypeEnum.TIME); + } + } + }); + + globalViewModel.getHandUpTime().observe(mainActivity, new Observer() { + @Override + public void onChanged(Integer handUpTime) { + tv_hand_time.setText(DateModel.getTime(handUpTime)); + } + }); + themeUIViewModel.getHand_time_visable().observe(mainActivity, new Observer() { @Override public void onChanged(Boolean aBoolean) { @@ -268,7 +295,9 @@ public class ThemeUIManager implements View.OnClickListener { if (isScreenLock()) return true; model.setHourSystem12(!model.isHourSystem12()); - updateHourSystem(); + globalViewModel.setHourSystem12(model.isHourSystem12()); + if(model.isHourSystem12()) + globalViewModel.setTime_hour(globalViewModel.getTime_hour().getValue()); return true; } }); @@ -290,13 +319,8 @@ public class ThemeUIManager implements View.OnClickListener { tv_break.setOnLongClickListener(new View.OnLongClickListener() { @Override public boolean onLongClick(View v) { - /*if(handUpAbla){ - if(showTimeType==ShowTimeType.COUNTING_DOWN) - setCurrentShowTimeType(ShowTimeType.TIME); - else - setCurrentShowTimeType(ShowTimeType.COUNTING_DOWN); - }*/ - return true; + clockStateMachine.handUpCountingDownCheck(); + return true; } }); @@ -394,18 +418,6 @@ public class ThemeUIManager implements View.OnClickListener { tv_screen_lock = themeRootView.findViewById(R.id.tv_screen_lock); tv_screen_lock.setOnClickListener(this); - /*tv_screen_lock.setOnLongClickListener(new View.OnLongClickListener() { - @Override - public boolean onLongClick(View v) { - if(!isFullScreen()){ - screenLock(true); - themeUIViewModel.setClockUITypeEnum(ClockThemeUITypeEnum.FULLSCREEN); - return true; - } - return false; - } - });*/ - tv_descript.init(mainActivity, false); } @@ -424,39 +436,23 @@ public class ThemeUIManager implements View.OnClickListener { tv_hours_system.setVisibility(View.GONE); } - //handUp - private void upHandStatic() { - /*if(handUpAbla) { - if(foregroundColor!=null) - this.tv_handup.setColorFilter(foregroundColor); - hand_time_visable=true; - this.tv_hand_time.setVisibility(View.VISIBLE); - }else{ - this.tv_handup.setColorFilter(R.color.colorPrimaryDark); - this.tv_hand_time.setVisibility(View.GONE); - if(showTimeType==ShowTimeType.COUNTING_DOWN) - setCurrentShowTimeType(ShowTimeType.TIME); - }*/ - } - private void setupHandUpTime() { - /*int saveHandUpTime=model.getHandUpTime(); + int saveHandUpTime=model.getHandUpTime(); int hour=0; int minute=0; if(handUpTimePopup==null) { - handUpTimePopup = new TimeSetupPopup(this); + handUpTimePopup = new TimeSetupPopup(mainActivity); handUpTimePopup.setOnSeekBarChangeListener(new TimeSetupPopup.OnTimeChangeListener() { @Override public void onChanged(int hour, int minute) { - model.setHandUpTime(hour*60+minute); - handUpAbla=true; if(hour==0&&minute==0) { - handUpAbla = false; model.setHandUpTime(-1); + globalViewModel.setHandUpAble(false); + }else{ + model.setHandUpTime(hour*60+minute); + globalViewModel.setHandUpTime(hour*60+minute); + globalViewModel.setHandUpAble(true); } - saveData(); - resetHandUpTime(); - upHandStatic(); } }); } @@ -465,7 +461,7 @@ public class ThemeUIManager implements View.OnClickListener { minute=saveHandUpTime-hour*60; } handUpTimePopup.init(hour,minute); - handUpTimePopup.showPopupWindow();*/ + handUpTimePopup.showPopupWindow(); } private void setupTempHandUpTime() { @@ -488,12 +484,6 @@ public class ThemeUIManager implements View.OnClickListener { handUpAbla=true;*/ } - private void resetHandUpTime() { - /*this.handUpTime = model.getHandUpTime(); - Log.d(TAG,"reset handUp time:"+handUpTime); - setDiscriptForModel();*/ - } - //Discript private void setDiscript(String disp) { tv_descript.setText(disp); @@ -518,14 +508,14 @@ public class ThemeUIManager implements View.OnClickListener { mainActivity.setup(); break; case R.id.tv_hand: - /*if(!handUpAbla&&handUpTime<0) { + int handUpTime=model.getHandUpTime(); + boolean handUpAbla=isHandUpAble(); + if(!handUpAbla&&handUpTime<0) { setupHandUpTime(); }else{ handUpAbla=!handUpAbla; - upHandStatic(); - resetHandUpTime(); - switchMode(MODE_NORMAL); - }*/ + globalViewModel.setHandUpAble(handUpAbla); + } break; case R.id.tv_hand_time: setupTempHandUpTime(); @@ -546,18 +536,11 @@ public class ThemeUIManager implements View.OnClickListener { weatherPopup.showPopupWindow(); break; case R.id.tv_screen_lock: - /*if(isFullScreen()) { - configThemeUITypeWithNoFullScreen(); - }*/ globalViewModel.setSrceenLock(!isScreenLock()); screenLock(!isScreenLock()); break; case R.id.tv_break: - /*if(showTimeType!= ClockTimeTypeEnum.COUNTING){ - setCurrentShowTimeType(ClockTimeTypeEnum.COUNTING); - }else{ - setCurrentShowTimeType(ClockTimeTypeEnum.TIME); - }*/ + clockStateMachine.countingCheck(); break; case R.id.tv_descript: setDiscript(SettingActivity.roundAutoQuotes()); @@ -696,7 +679,6 @@ public class ThemeUIManager implements View.OnClickListener { } } - private boolean isFullScreen(){ return themeUIViewModel.getClockUITypeEnum().getValue()==ClockThemeUITypeEnum.FULLSCREEN; } @@ -708,9 +690,6 @@ public class ThemeUIManager implements View.OnClickListener { themeUIViewModel.setClockUITypeEnum(ClockThemeUITypeEnum.SETTING); } - protected void reflushFontStyle(TimeFontStyle fontStyle) { - FontUtils.getInstance().replaceFontFromAsset(tv_date, "fonts/" + fontStyle.name + ".ttf"); - } public void screenLock(boolean locked) { tv_screen_lock.setImageResource(locked ? R.drawable.ic_screen_lock : R.drawable.ic_screen_unlock); diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/AbstractThemeUIFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/AbstractThemeUIFragment.java new file mode 100644 index 0000000..cb582e1 --- /dev/null +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/AbstractThemeUIFragment.java @@ -0,0 +1,670 @@ +package clock.socoolby.com.clock.fragment; + +import android.annotation.TargetApi; +import android.os.Build; +import android.os.Bundle; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.FrameLayout; +import android.widget.ImageButton; +import android.widget.TextView; + +import androidx.fragment.app.Fragment; +import androidx.lifecycle.Observer; +import androidx.lifecycle.ViewModelProviders; + +import java.util.Timer; +import java.util.TimerTask; + +import clock.socoolby.com.clock.ClockApplication; +import clock.socoolby.com.clock.MainActivity; +import clock.socoolby.com.clock.R; +import clock.socoolby.com.clock.SettingActivity; +import clock.socoolby.com.clock.model.DateModel; +import clock.socoolby.com.clock.model.SharePerferenceModel; +import clock.socoolby.com.clock.pop.CalendarPopup; +import clock.socoolby.com.clock.pop.ColorPickerPop; +import clock.socoolby.com.clock.pop.TimeSetupPopup; +import clock.socoolby.com.clock.pop.WeatherPopup; +import clock.socoolby.com.clock.state.ClockInterfaceTypeEnum; +import clock.socoolby.com.clock.state.ClockStateMachine; +import clock.socoolby.com.clock.state.ClockThemeUITypeEnum; +import clock.socoolby.com.clock.state.ClockTimeTypeEnum; +import clock.socoolby.com.clock.viewmodel.DigitViewModel; +import clock.socoolby.com.clock.viewmodel.GlobalViewModel; +import clock.socoolby.com.clock.viewmodel.SimulateViewModel; +import clock.socoolby.com.clock.viewmodel.ThemeUIViewModel; +import clock.socoolby.com.clock.viewmodel.ViewModelFactory; +import clock.socoolby.com.clock.widget.textview.AutoScrollTextView; + +public abstract class AbstractThemeUIFragment extends Fragment implements View.OnClickListener { + + public static final String TAG= AbstractThemeUIFragment.class.getSimpleName(); + + public int layoutId; + + private TextView tv_date; + private TextView tv_day; + private TextView tv_weather; + private AutoScrollTextView tv_descript; + private ImageButton tv_setting; + private ImageButton tv_handup; + + private ImageButton tv_hours_system; + private ImageButton tv_background_image_hand; + private ImageButton tv_break; + + private ImageButton tv_clock_interface; + + //颜色相关 + private ImageButton tv_background_color; + private ImageButton tv_foreground_color; + private ImageButton tv_foreground_color1; + + private TextView tv_hand_time; + //private boolean hand_time_visable=true; + private ImageButton tv_screen_lock; + + ColorPickerPop colorPickerDialog; + TimeSetupPopup handUpTimePopup; + CalendarPopup calendarPopup; + WeatherPopup weatherPopup; + + GlobalViewModel globalViewModel; + DigitViewModel digitViewModel; + SimulateViewModel simulateViewModel; + ThemeUIViewModel themeUIViewModel; + + MainActivity mainActivity; + + public AbstractThemeUIFragment(int layoutId){ + this.layoutId=layoutId; + } + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + this.globalViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(),ClockApplication.getInstance().getEntityManager())).get(GlobalViewModel.class); + this.digitViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(),ClockApplication.getInstance().getEntityManager())).get(DigitViewModel.class); + this.simulateViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(),ClockApplication.getInstance().getEntityManager())).get(SimulateViewModel.class); + this.themeUIViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(),ClockApplication.getInstance().getEntityManager())).get(ThemeUIViewModel.class); + this.mainActivity = (MainActivity)getActivity(); + this.model = ClockApplication.getInstance().getModel(); + this.clockStateMachine=mainActivity.getClockStateMachine(); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + View themeRootView=inflater.inflate(layoutId, container, false); + + tv_background_image_hand = themeRootView.findViewById(R.id.tv_background_image_hand); + tv_background_image_hand.setOnClickListener(this); + tv_background_image_hand.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + mainActivity.configBackGroundImage(); + return true; + } + }); + + tv_date = themeRootView.findViewById(R.id.tv_date); + tv_date.setOnClickListener(this); + tv_date.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + changeThemeTypeCheck(); + return true; + } + }); + + tv_day = themeRootView.findViewById(R.id.tv_day); + tv_day.setOnClickListener(this); + tv_day.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + if (isScreenLock()) + return true; + model.setHourSystem12(!model.isHourSystem12()); + globalViewModel.setHourSystem12(model.isHourSystem12()); + if(model.isHourSystem12()) + globalViewModel.setTime_hour(globalViewModel.getTime_hour().getValue()); + return true; + } + }); + + tv_weather = themeRootView.findViewById(R.id.tv_weather); + tv_weather.setOnClickListener(this); + tv_descript = themeRootView.findViewById(R.id.tv_descript); + tv_descript.setOnClickListener(this); + tv_descript.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + //changeBackGroundAnimator(ANIMATOR_TEXTLED); + return true; + } + }); + + tv_break = themeRootView.findViewById(R.id.tv_break); + tv_break.setOnClickListener(this); + tv_break.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + clockStateMachine.handUpCountingDownCheck(); + return true; + } + }); + + tv_handup = themeRootView.findViewById(R.id.tv_hand); + tv_handup.setOnClickListener(this); + tv_handup.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View view) { + if (isScreenLock()) + return true; + setupHandUpTime(); + return true; + } + }); + tv_hand_time = themeRootView.findViewById(R.id.tv_hand_time); + tv_hand_time.setOnClickListener(this); + tv_hand_time.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + //hand_time_visable=false; + tv_hand_time.setVisibility(View.GONE); + return true; + } + }); + + tv_hours_system = themeRootView.findViewById(R.id.tv_hours_system); + + tv_background_color = themeRootView.findViewById(R.id.tv_background_color); + tv_background_color.setOnClickListener(this); + + tv_foreground_color = themeRootView.findViewById(R.id.tv_foreground_color); + tv_foreground_color.setOnClickListener(this); + tv_foreground_color.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + if (isScreenLock()) + return true; + if (colorPickerDialog == null) + colorPickerDialog = new ColorPickerPop(getActivity()); + + colorPickerDialog.setOnColorChangeListenter(new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + model.setForegroundColor(color); + globalViewModel.setForegroundColor(color); + tv_foreground_color.setColorFilter(color); + autoFullScreenCheck(); + } + + @Override + public void onBack() { + } + }); + colorPickerDialog.show(model.getForegroundColor()); + return true; + } + }); + + tv_foreground_color1 = themeRootView.findViewById(R.id.tv_foreground_color1); + tv_foreground_color1.setOnClickListener(this); + tv_foreground_color1.setOnLongClickListener(new View.OnLongClickListener() { + @Override + public boolean onLongClick(View v) { + if (isScreenLock()) + return true; + if (colorPickerDialog == null) + colorPickerDialog = new ColorPickerPop(getActivity()); + + colorPickerDialog.setOnColorChangeListenter(new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + model.setForegroundColor1(color); + globalViewModel.setForegroundColor(color); + tv_foreground_color1.setColorFilter(color); + autoFullScreenCheck(); + } + + @Override + public void onBack() { + } + }); + colorPickerDialog.show(model.getForegroundColor1()); + return true; + } + }); + + tv_clock_interface = themeRootView.findViewById(R.id.tv_clock_interface); + tv_clock_interface.setOnClickListener(this); + + + tv_setting = themeRootView.findViewById(R.id.tv_setting); + tv_setting.setOnClickListener(this); + + + tv_screen_lock = themeRootView.findViewById(R.id.tv_screen_lock); + tv_screen_lock.setOnClickListener(this); + + //tv_descript.init(mainActivity, false); + bindViewModel(); + return themeRootView; + } + + private SharePerferenceModel model; + + private boolean autoFullScreen=false; + + private int runDelaySecond=10000; + + private boolean running=false; + + Timer timer=null; + + ClockStateMachine clockStateMachine; + + private void autoFullScreenCheck(){ + if(!autoFullScreen) + return; + if(timer==null) + timer = new Timer(); + if(running){ + timer.cancel(); + } + running=true; + Log.d("themeUiManager","autoFullScreen task created ..."); + timer.schedule(new TimerTask() { + public void run() { + themeUIViewModel.setClockUITypeEnum(ClockThemeUITypeEnum.FULLSCREEN); + this.cancel(); + } + }, runDelaySecond); + } + + + abstract void changeThemeTypeCheck(); + + private void bindViewModel() { + + /*themeUIViewModel.getThemeName().observe(mainActivity, new Observer() { + @Override + public void onChanged(String s) { + switchThemeType(s); + } + });*/ + + themeUIViewModel.getClockUITypeEnum().observe(mainActivity, new Observer() { + @Override + public void onChanged(ClockThemeUITypeEnum uiTypeEnum) { + switchMode(uiTypeEnum); + } + }); + + globalViewModel.getHourSystem12().observe(mainActivity, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + tv_hours_system.setVisibility(aBoolean ? View.VISIBLE : View.GONE); + } + }); + + globalViewModel.getTime_hour().observe(mainActivity, new Observer() { + @Override + public void onChanged(Integer integer) { + tv_hours_system.setImageResource(integer > 12 ? R.drawable.ic_pm : R.drawable.ic_am); + } + }); + + themeUIViewModel.getDescription().observe(mainActivity, new Observer() { + @Override + public void onChanged(String s) { + setDiscript(s); + } + }); + + globalViewModel.getForegroundColor().observe(mainActivity, new Observer() { + @Override + public void onChanged(Integer integer) { + setForegroundColor(integer); + } + }); + + globalViewModel.getHandUpAble().observe(mainActivity, new Observer() { + @Override + public void onChanged(Boolean handUpAbla) { + if(handUpAbla) { + tv_handup.setColorFilter(globalViewModel.getForegroundColor().getValue()); + tv_hand_time.setVisibility(View.VISIBLE); + }else{ + tv_handup.setColorFilter(R.color.colorPrimaryDark); + tv_hand_time.setVisibility(View.GONE); + if(clockStateMachine.getCurrentShowTimeType()== ClockTimeTypeEnum.COUNTING_DOWN) + clockStateMachine.setCurrentShowTimeType(ClockTimeTypeEnum.TIME); + } + } + }); + + globalViewModel.getHandUpTime().observe(mainActivity, new Observer() { + @Override + public void onChanged(Integer handUpTime) { + tv_hand_time.setText(DateModel.getTime(handUpTime)); + } + }); + + themeUIViewModel.getHand_time_visable().observe(mainActivity, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + tv_hand_time.setVisibility(aBoolean ? View.VISIBLE : View.GONE); + } + }); + + + themeUIViewModel.getWeatherDescription().observe(mainActivity, new Observer() { + @Override + public void onChanged(String s) { + tv_weather.setText(s); + } + }); + + + themeUIViewModel.getWeekDescription().observe(mainActivity, new Observer() { + @Override + public void onChanged(String s) { + tv_date.setText(s); + } + }); + + themeUIViewModel.getDayDescription().observe(mainActivity, new Observer() { + @Override + public void onChanged(String s) { + tv_day.setText(s); + } + }); + } + + + private void updateColorSettingButtunColor(){ + tv_foreground_color.setColorFilter(model.getForegroundColor()); + tv_foreground_color1.setColorFilter(model.getForegroundColor1()); + } + + private boolean isScreenLock() { + return globalViewModel.getSrceenLock().getValue(); + } + + private boolean isHandUpAble() { + return globalViewModel.getHandUpAble().getValue(); + } + + private void updateHourSystem() { + if (model.isHourSystem12()) + tv_hours_system.setVisibility(View.VISIBLE); + else + tv_hours_system.setVisibility(View.GONE); + } + + private void setupHandUpTime() { + int saveHandUpTime=model.getHandUpTime(); + int hour=0; + int minute=0; + if(handUpTimePopup==null) { + handUpTimePopup = new TimeSetupPopup(mainActivity); + handUpTimePopup.setOnSeekBarChangeListener(new TimeSetupPopup.OnTimeChangeListener() { + @Override + public void onChanged(int hour, int minute) { + if(hour==0&&minute==0) { + model.setHandUpTime(-1); + globalViewModel.setHandUpAble(false); + }else{ + model.setHandUpTime(hour*60+minute); + globalViewModel.setHandUpTime(hour*60+minute); + globalViewModel.setHandUpAble(true); + } + } + }); + } + if(saveHandUpTime>0){ + hour=saveHandUpTime/60; + minute=saveHandUpTime-hour*60; + } + handUpTimePopup.init(hour,minute); + handUpTimePopup.showPopupWindow(); + } + + private void setupTempHandUpTime() { + /*handUpAbla=false; + int hour=0; + int minute=0; + if(handUpTimePopup==null) { + handUpTimePopup = new TimeSetupPopup(this); + handUpTimePopup.setOnSeekBarChangeListener(new TimeSetupPopup.OnTimeChangeListener() { + @Override + public void onChanged(int hour, int minute) { + handUpTime=hour*60+minute; + } + }); + } + hour=handUpTime/60; + minute=handUpTime-hour*60; + handUpTimePopup.init(hour,minute); + handUpTimePopup.showPopupWindow(); + handUpAbla=true;*/ + } + + //Discript + private void setDiscript(String disp) { + tv_descript.setText(disp); + tv_descript.startScrollIfAble(); + } + + private void setDiscriptForModel() { + String dis = model.getDescription(); + if (dis == null || dis.isEmpty()) + dis = SettingActivity.roundFamousQuotes(); + setDiscript(dis); + } + + @TargetApi(Build.VERSION_CODES.HONEYCOMB) + @Override + public void onClick(View view) { + if (isScreenLock() && view.getId() != R.id.tv_screen_lock && view.getId() != R.id.tv_handup_image) { + return; + } + switch (view.getId()) { + case R.id.tv_setting: + mainActivity.setup(); + break; + case R.id.tv_hand: + int handUpTime=model.getHandUpTime(); + boolean handUpAbla=isHandUpAble(); + if(!handUpAbla&&handUpTime<0) { + setupHandUpTime(); + }else{ + handUpAbla=!handUpAbla; + globalViewModel.setHandUpAble(handUpAbla); + } + break; + case R.id.tv_hand_time: + setupTempHandUpTime(); + break; + case R.id.tv_day: + digitViewModel.setDisplaySecond(!model.isDisplaySecond()); + break; + case R.id.tv_date: + if (calendarPopup == null) + calendarPopup = new CalendarPopup(mainActivity); + calendarPopup.showPopupWindow(); + calendarPopup.setCurrentDay(); + break; + case R.id.tv_weather: + if (weatherPopup == null) + weatherPopup = new WeatherPopup(mainActivity); + weatherPopup.init(mainActivity.weatherAdape.getWeatherList(), model.getCity() + " PM2.5 : " + mainActivity.weatherAdape.getmPM25()); + weatherPopup.showPopupWindow(); + break; + case R.id.tv_screen_lock: + globalViewModel.setSrceenLock(!isScreenLock()); + screenLock(!isScreenLock()); + break; + case R.id.tv_break: + clockStateMachine.countingCheck(); + break; + case R.id.tv_descript: + setDiscript(SettingActivity.roundAutoQuotes()); + break; + case R.id.tv_background_color: + if (colorPickerDialog == null) + colorPickerDialog = new ColorPickerPop(mainActivity); + + colorPickerDialog.setOnColorChangeListenter(new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + globalViewModel.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + colorPickerDialog.show(model.getBackgroundColor()); + break; + case R.id.tv_background_image_hand: + if (globalViewModel.getBackgroundImageUri().getValue() == null) + mainActivity.configBackGroundImage(); + else + globalViewModel.setBackgroundImageVisable(!globalViewModel.getBackgroundImageVisable().getValue()); + break; + case R.id.tv_foreground_color: + globalViewModel.setForegroundColor(model.getForegroundColor()); + break; + case R.id.tv_foreground_color1: + globalViewModel.setForegroundColor(model.getForegroundColor1()); + break; + case R.id.tv_clock_interface: + changeClockInterface(); + break; + } + autoFullScreenCheck(); + } + + + protected void changeClockInterface() { + ClockInterfaceTypeEnum currentClockInterface = globalViewModel.getClockInterfaceTypeEnum().getValue(); + switch (currentClockInterface) { + case Digit: + currentClockInterface = ClockInterfaceTypeEnum.Simulate; + break; + default: + currentClockInterface = ClockInterfaceTypeEnum.Digit; + } + globalViewModel.setClockInterfaceTypeEnum(currentClockInterface); + } + + protected void setForegroundColor(Integer color) { + tv_date.setTextColor(color); + tv_day.setTextColor(color); + tv_weather.setTextColor(color); + tv_descript.setTextColor(color); + + tv_handup.setColorFilter(color); + tv_screen_lock.setColorFilter(color); + tv_setting.setColorFilter(color); + tv_background_color.setColorFilter(color); + tv_hand_time.setTextColor(color); + tv_hours_system.setColorFilter(color); + tv_background_image_hand.setColorFilter(color); + + tv_break.setColorFilter(color); + + tv_clock_interface.setColorFilter(color); + } + + + private void switchMode(ClockThemeUITypeEnum mode) { + Log.d(TAG, "switch mode to:" + mode); + switch (mode) { + case FULLSCREEN: + tv_date.setVisibility(View.GONE); + tv_day.setVisibility(View.GONE); + tv_weather.setVisibility(View.GONE); + tv_descript.setVisibility(View.GONE); + + tv_handup.setVisibility(View.GONE); + + tv_setting.setVisibility(View.GONE); + tv_background_color.setVisibility(View.GONE); + + tv_background_color.setVisibility(View.GONE); + tv_foreground_color.setVisibility(View.GONE); + tv_foreground_color1.setVisibility(View.GONE); + tv_background_image_hand.setVisibility(View.GONE); + + tv_break.setVisibility(View.GONE); + + tv_clock_interface.setVisibility(View.GONE); + + tv_screen_lock.setVisibility(View.GONE); + break; + case NORMAL: + tv_date.setVisibility(View.VISIBLE); + tv_day.setVisibility(View.VISIBLE); + tv_weather.setVisibility(View.VISIBLE); + tv_descript.setVisibility(View.VISIBLE); + + tv_handup.setVisibility(View.VISIBLE); + tv_break.setVisibility(View.VISIBLE); + + tv_setting.setVisibility(View.GONE); + tv_background_color.setVisibility(View.GONE); + tv_foreground_color.setVisibility(View.GONE); + tv_foreground_color1.setVisibility(View.GONE); + tv_background_image_hand.setVisibility(View.GONE); + + tv_clock_interface.setVisibility(View.GONE); + + tv_screen_lock.setVisibility(View.VISIBLE); + break; + case SETTING: + tv_date.setVisibility(View.VISIBLE); + tv_day.setVisibility(View.VISIBLE); + tv_weather.setVisibility(View.VISIBLE); + tv_descript.setVisibility(View.VISIBLE); + + tv_handup.setVisibility(View.VISIBLE); + tv_break.setVisibility(View.VISIBLE); + + tv_setting.setVisibility(View.VISIBLE); + tv_background_color.setVisibility(View.VISIBLE); + tv_foreground_color.setVisibility(View.VISIBLE); + tv_foreground_color1.setVisibility(View.VISIBLE); + tv_background_image_hand.setVisibility(View.VISIBLE); + + tv_clock_interface.setVisibility(View.VISIBLE); + + tv_screen_lock.setVisibility(View.VISIBLE); + break; + } + } + + private boolean isFullScreen(){ + return themeUIViewModel.getClockUITypeEnum().getValue()==ClockThemeUITypeEnum.FULLSCREEN; + } + + public void configThemeUITypeWithNoFullScreen(){ + if(globalViewModel.getClockInterfaceTypeEnum().getValue()==ClockInterfaceTypeEnum.Digit) + themeUIViewModel.setClockUITypeEnum(ClockThemeUITypeEnum.NORMAL); + else + themeUIViewModel.setClockUITypeEnum(ClockThemeUITypeEnum.SETTING); + } + + + public void screenLock(boolean locked) { + tv_screen_lock.setImageResource(locked ? R.drawable.ic_screen_lock : R.drawable.ic_screen_unlock); + } + + +} diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/AlterFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/AlterFragment.java index fe0b830..06b51fc 100644 --- a/app/src/main/java/clock/socoolby/com/clock/fragment/AlterFragment.java +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/AlterFragment.java @@ -14,7 +14,8 @@ import android.widget.TextView; import clock.socoolby.com.clock.ClockApplication; import clock.socoolby.com.clock.R; -import clock.socoolby.com.clock.state.ClockModeEnum; +import clock.socoolby.com.clock.state.ClockStateMachine; +import clock.socoolby.com.clock.utils.Player; import clock.socoolby.com.clock.viewmodel.AlterViewModel; import clock.socoolby.com.clock.viewmodel.GlobalViewModel; import clock.socoolby.com.clock.viewmodel.ViewModelFactory; @@ -29,10 +30,15 @@ public class AlterFragment extends Fragment { GlobalViewModel globalViewModel; AlterViewModel alterViewModel; + ClockStateMachine clockStateMachine; + private TextView tv_handup_text; - public AlterFragment() { - // Required empty public constructor + private int handUPDialy=0; + + + public AlterFragment(ClockStateMachine clockStateMachine) { + this.clockStateMachine=clockStateMachine; } @@ -43,6 +49,11 @@ public class AlterFragment extends Fragment { alterViewModel=ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(),ClockApplication.getInstance().getEntityManager())).get(AlterViewModel.class); } + @Override + public void onResume() { + super.onResume(); + } + @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { @@ -59,24 +70,36 @@ public class AlterFragment extends Fragment { } private void bindViewModel(){ - alterViewModel.getHandUpDescription().observe(this, new Observer() { - @Override - public void onChanged(String s) { - tv_handup_text.setText(s); - } - }); + alterViewModel.getHandUPDialy().observe(this, new Observer() { + @Override + public void onChanged(Integer integer) { + handUPDialy=integer; + } + }); - globalViewModel.getHandUpTime().observe(this, new Observer() { - @Override - public void onChanged(Integer time) { - if(time==0) - endHandUp(false); - } - }); + globalViewModel.getHeartbeat().observe(this, new Observer() { + @Override + public void onChanged(Boolean aBoolean) { + handUPDialy--; + tv_handup_text.setText("hand up ! \t"+handUPDialy); + if(handUPDialy==0) + endHandUp(false); + else + Player.getInstance().playHandUp(ClockApplication.getContext()); + } + }); + + globalViewModel.getForegroundColor().observe(this, new Observer() { + @Override + public void onChanged(Integer integer) { + tv_handup_text.setTextColor(integer); + } + }); } + private void endHandUp(boolean userCheck){ - globalViewModel.getClockModeEnum().setValue(ClockModeEnum.NORMAL); + clockStateMachine.stopHandUp(userCheck); } } diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockConfigFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockConfigFragment.java new file mode 100644 index 0000000..dafa569 --- /dev/null +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockConfigFragment.java @@ -0,0 +1,352 @@ +package clock.socoolby.com.clock.fragment; + +import android.graphics.Color; +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Button; +import android.widget.CheckBox; +import android.widget.LinearLayout; +import android.widget.RadioButton; +import android.widget.RadioGroup; +import android.widget.TextView; + +import androidx.fragment.app.Fragment; +import androidx.lifecycle.ViewModelProviders; + +import butterknife.BindView; +import butterknife.ButterKnife; +import butterknife.Unbinder; +import clock.socoolby.com.clock.ClockApplication; +import clock.socoolby.com.clock.R; +import clock.socoolby.com.clock.pop.ColorPickerPop; +import clock.socoolby.com.clock.viewmodel.DigitViewModel; +import clock.socoolby.com.clock.viewmodel.GlobalViewModel; +import clock.socoolby.com.clock.viewmodel.ViewModelFactory; +import clock.socoolby.com.clock.widget.textview.ShadowTypeEnum; +import clock.socoolby.com.clock.widget.textview.charanimator.CharAnimatorEnum; + +public class DigitClockConfigFragment extends Fragment { + + public static final String TAG = SimulateClockFragment.class.getSimpleName(); + + public static final String NAME = "simulateClockConfig"; + + DigitViewModel digitViewModel; + GlobalViewModel globalViewModel; + + @BindView(R.id.tv_hourSystem12) + RadioButton tvHourSystem12; + @BindView(R.id.tv_hourSystem24) + RadioButton tvHourSystem24; + @BindView(R.id.tv_hourSystem_group) + RadioGroup tvHourSystemGroup; + @BindView(R.id.tv_secoundShow) + CheckBox tvSecoundShow; + @BindView(R.id.text_style_group1) + LinearLayout textStyleGroup1; + @BindView(R.id.textView3) + TextView textView3; + @BindView(R.id.tv_textStyle_numal) + RadioButton tvTextStyleNumal; + @BindView(R.id.tv_textStyle_shadow) + RadioButton tvTextStyleShadow; + @BindView(R.id.tv_textStyle_relief) + RadioButton tvTextStyleRelief; + @BindView(R.id.tv_textStyle_group) + RadioGroup tvTextStyleGroup; + @BindView(R.id.tv_textStyle_reflect) + CheckBox tvTextStyleReflect; + @BindView(R.id.text_style_group2) + LinearLayout textStyleGroup2; + @BindView(R.id.tv_textAnim_down) + RadioButton tvTextAnimDown; + @BindView(R.id.tv_textAnim_up) + RadioButton tvTextAnimUp; + @BindView(R.id.tv_textAnim_downflit) + RadioButton tvTextAnimDownflit; + @BindView(R.id.tv_textAnim_upflat) + RadioButton tvTextAnimUpflat; + @BindView(R.id.tv_textAnim_group) + RadioGroup tvTextAnimGroup; + @BindView(R.id.text_style_group3) + LinearLayout textStyleGroup3; + @BindView(R.id.tv_textAnim_numal) + RadioButton tvTextAnimNumal; + @BindView(R.id.textView2) + CheckBox textView2; + @BindView(R.id.button4) + Button button4; + @BindView(R.id.button5) + Button button5; + @BindView(R.id.button6) + Button button6; + @BindView(R.id.button7) + Button button7; + @BindView(R.id.button8) + Button button8; + @BindView(R.id.text_style_group4) + LinearLayout textStyleGroup4; + @BindView(R.id.textView) + TextView textView; + @BindView(R.id.editText) + TextView textView1; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + globalViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(), ClockApplication.getInstance().getEntityManager())).get(GlobalViewModel.class); + digitViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(), ClockApplication.getInstance().getEntityManager())).get(DigitViewModel.class); + } + + + private Unbinder unbinder; + + private ColorPickerPop colorPickerDialog; + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + View view = inflater.inflate(R.layout.fragment_digit_config, container, false); + + unbinder = ButterKnife.bind(this, view); + + loadForViewModel(); + + tvHourSystemGroup.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() { + @Override + public void onCheckedChanged(RadioGroup group, int checkedId) { + switch (checkedId) { + case R.id.tv_hourSystem12: + globalViewModel.setHourSystem12(tvHourSystem12.isChecked()); + break; + case R.id.tv_hourSystem24: + globalViewModel.setHourSystem12(tvHourSystem12.isChecked()); + break; + default: + break; + } + } + }); + + + tvTextStyleGroup.setOnCheckedChangeListener((RadioGroup group, int checkedId) -> { + ShadowTypeEnum shadowTypeEnum = ShadowTypeEnum.NOSETUP; + switch (checkedId) { + case R.id.tv_textStyle_numal: + shadowTypeEnum = ShadowTypeEnum.NOSETUP; + break; + case R.id.tv_textStyle_shadow: + shadowTypeEnum = ShadowTypeEnum.SHADOW; + break; + case R.id.tv_textStyle_relief: + shadowTypeEnum = ShadowTypeEnum.RELIEF; + break; + } + digitViewModel.setShadowType(shadowTypeEnum); + }); + + tvSecoundShow.setOnCheckedChangeListener((group, checkedId) -> + { + digitViewModel.setDisplaySecond(group.isChecked()); + }); + + tvTextStyleReflect.setOnCheckedChangeListener((group, checkedId) -> { + digitViewModel.setReflectedAble(group.isChecked()); + }); + + tvTextAnimGroup.setOnCheckedChangeListener((group, checkedId) -> { + CharAnimatorEnum charAnimatorEnum = CharAnimatorEnum.NOSETUP; + switch (checkedId) { + case R.id.tv_textAnim_down: + charAnimatorEnum = CharAnimatorEnum.UP2DOWN; + break; + case R.id.tv_textAnim_up: + charAnimatorEnum = CharAnimatorEnum.DOWN2UP; + break; + case R.id.tv_textAnim_downflit: + charAnimatorEnum = CharAnimatorEnum.Marquee3D_Down; + break; + case R.id.tv_textAnim_upflat: + charAnimatorEnum = CharAnimatorEnum.Marquee3D_Up; + break; + } + if (charAnimatorEnum != CharAnimatorEnum.NOSETUP) + if (digitViewModel.getDisplaySecond().getValue()) + digitViewModel.setTimeText("88:88:88"); + else + digitViewModel.setTimeText("88:88"); + digitViewModel.setTimeCharAnimatorType(charAnimatorEnum); + }); + + textView2.setOnCheckedChangeListener((group, checkedId) -> { + digitViewModel.setLinearGradientAble(textView2.isChecked()); + }); + + button4.setOnClickListener(view1 -> + changeGradientColor(button4, 0) + ); + + button5.setOnClickListener((view1) -> { + changeGradientColor(button5, 1); + }); + + button6.setOnClickListener(view1 -> { + changeGradientColor(button6, 2); + }); + + button7.setOnClickListener((view1) -> { + changeGradientColor(button7, 3); + }); + + button8.setOnClickListener((view1) -> { + changeGradientColor(button8, 4); + }); + + return view; + } + + private void changeGradientColor(Button view, int order) { + if (colorPickerDialog == null) + colorPickerDialog = new ColorPickerPop(getActivity()); + + colorPickerDialog.setOnColorChangeListenter(new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + confColors[order] = color; + digitViewModel.setTimeLinearGradientColorsArray(confColors); + view.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + colorPickerDialog.show(confColors[order]); + } + + + /** + * onDestroyView中进行解绑操作 + */ + @Override + public void onDestroyView() { + super.onDestroyView(); + unbinder.unbind(); + } + + Integer[] defGradientColorsArray = new Integer[]{Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK}; + Integer[] confColors; + + private void loadForViewModel() { + + if (globalViewModel.getHourSystem12().getValue()) + tvHourSystem12.setChecked(true); + else + tvHourSystem24.setChecked(true); + + + tvSecoundShow.setChecked(digitViewModel.getDisplaySecond().getValue()); + + + switch (digitViewModel.getShadowType().getValue()) { + case NOSETUP: + tvTextStyleNumal.setChecked(true); + break; + case RELIEF: + tvTextStyleRelief.setChecked(true); + break; + case SHADOW: + tvTextStyleShadow.setChecked(true); + break; + } + + + tvTextStyleReflect.setChecked(digitViewModel.getReflectedAble().getValue()); + + switch (digitViewModel.getTimeCharAnimatorType().getValue()) { + case NOSETUP: + tvTextAnimNumal.setChecked(true); + break; + case UP2DOWN: + tvTextAnimDown.setChecked(true); + break; + case DOWN2UP: + tvTextAnimUp.setChecked(true); + break; + case Marquee3D_Down: + tvTextAnimDownflit.setChecked(true); + break; + case Marquee3D_Up: + tvTextAnimUpflat.setChecked(true); + break; + } + + textView2.setChecked(digitViewModel.getLinearGradientAble().getValue()); + + confColors = digitViewModel.getTimeLinearGradientColorsArray().getValue(); + + if (confColors == null) + confColors = defGradientColorsArray; + + button4.setBackgroundColor(confColors[0]); + button5.setBackgroundColor(confColors[1]); + button6.setBackgroundColor(confColors[2]); + button7.setBackgroundColor(confColors[3]); + button8.setBackgroundColor(confColors[4]); + + + digitViewModel.getLinearGradientAble().observe(this, (able) -> { + button4.setClickable(able); + button5.setClickable(able); + button6.setClickable(able); + button7.setClickable(able); + button8.setClickable(able); + }); + + + setTextColor(globalViewModel.getForegroundColor().getValue()); + } + + private void setTextColor(int color) { + + tvHourSystem12.setTextColor(color); + + tvHourSystem24.setTextColor(color); + + tvSecoundShow.setTextColor(color); + + textView3.setTextColor(color); + + tvTextStyleNumal.setTextColor(color); + + tvTextStyleShadow.setTextColor(color); + + tvTextStyleRelief.setTextColor(color); + + tvTextStyleReflect.setTextColor(color); + + + tvTextAnimDown.setTextColor(color); + + tvTextAnimUp.setTextColor(color); + + tvTextAnimDownflit.setTextColor(color); + + tvTextAnimUpflat.setTextColor(color); + + tvTextAnimNumal.setTextColor(color); + + textView2.setTextColor(color); + textView1.setTextColor(color); + textView.setTextColor(color); + + button4.setTextColor(color); + button5.setTextColor(color); + button6.setTextColor(color); + button7.setTextColor(color); + button8.setTextColor(color); + + } +} diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockFragment.java index aa351a8..4f72054 100644 --- a/app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockFragment.java +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/DigitClockFragment.java @@ -87,7 +87,7 @@ public class DigitClockFragment extends Fragment { @Override public void onChanged(Integer[] integers) { if(integers==null) { - tv_time.setLinearGradientAble(false); + tv_time.setLinearGradientColors(null); return; } int[] toInts=new int[integers.length]; diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockConfigFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockConfigFragment.java new file mode 100644 index 0000000..8827bde --- /dev/null +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockConfigFragment.java @@ -0,0 +1,239 @@ +package clock.socoolby.com.clock.fragment; + +import android.os.Bundle; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.Button; +import android.widget.RadioButton; +import android.widget.RadioGroup; +import android.widget.ScrollView; +import android.widget.TextView; + +import androidx.fragment.app.Fragment; +import androidx.lifecycle.ViewModelProviders; + +import butterknife.BindView; +import butterknife.ButterKnife; +import butterknife.Unbinder; +import clock.socoolby.com.clock.ClockApplication; +import clock.socoolby.com.clock.R; +import clock.socoolby.com.clock.pop.ColorPickerPop; +import clock.socoolby.com.clock.viewmodel.GlobalViewModel; +import clock.socoolby.com.clock.viewmodel.SimulateViewModel; +import clock.socoolby.com.clock.viewmodel.ViewModelFactory; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.pointer.DefaultPointer; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.pointer.LeafPointer; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.pointer.LeafTwoPointer; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.pointer.SecondTailPointer; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.pointer.SwordPointer; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.pointer.TrianglePointer; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.pointer.TwoStepPointer; + +public class SimulateClockConfigFragment extends Fragment { + + public static final String TAG = SimulateClockFragment.class.getSimpleName(); + + public static final String NAME = "simulateClockConfig"; + + SimulateViewModel simulateViewModel; + GlobalViewModel globalViewModel; + @BindView(R.id.tv_simulate_color_pointer) + Button tvSimulateColorPointer; + @BindView(R.id.tv_simulate_color_scale) + Button tvSimulateColorScale; + @BindView(R.id.tv_simulate_color_scalep_particularly) + Button tvSimulateColorScalepParticularly; + @BindView(R.id.tv_simulate_color_text) + Button tvSimulateColorText; + @BindView(R.id.tv_simulate_color_outline) + Button tvSimulateColorOutline; + @BindView(R.id.textView4) + TextView textView4; + @BindView(R.id.tv_simulate_text_show_hide) + RadioButton tvSimulateTextShowHide; + @BindView(R.id.tv_simulate_text_show_all) + RadioButton tvSimulateTextShowAll; + @BindView(R.id.tv_simulate_text_show_four) + RadioButton tvSimulateTextShowFour; + @BindView(R.id.tv_simulate_text_show_group) + RadioGroup tvSimulateTextShowGroup; + @BindView(R.id.textView5) + TextView textView5; + @BindView(R.id.tv_simulate_pointer_style_1) + Button tvSimulatePointerStyle1; + @BindView(R.id.tv_simulate_pointer_style_2) + Button tvSimulatePointerStyle2; + @BindView(R.id.tv_simulate_pointer_style_3) + Button tvSimulatePointerStyle3; + @BindView(R.id.tv_simulate_pointer_style_4) + Button tvSimulatePointerStyle4; + @BindView(R.id.pointer_list) + ScrollView pointerList; + @BindView(R.id.tv_simulate_pointer_style_0) + Button tvSimulatePointerStyle0; + @BindView(R.id.tv_simulate_pointer_style_5) + Button tvSimulatePointerStyle5; + @BindView(R.id.tv_simulate_pointer_style_6) + Button tvSimulatePointerStyle6; + @BindView(R.id.tv_simulate_color_pointer_second) + Button tvSimulateColorPointerSecond; + + private Unbinder unbinder; + + private ColorPickerPop colorPickerDialog; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + globalViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(), ClockApplication.getInstance().getEntityManager())).get(GlobalViewModel.class); + simulateViewModel = ViewModelProviders.of(getActivity(), new ViewModelFactory(ClockApplication.getInstance().getModel(), ClockApplication.getInstance().getEntityManager())).get(SimulateViewModel.class); + } + + @Override + public void onResume() { + super.onResume(); + } + + @Override + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + View view = inflater.inflate(R.layout.fragment_simulate_config, container, false); + unbinder = ButterKnife.bind(this, view); + + bindViewModel(); + + tvSimulateTextShowGroup.setOnCheckedChangeListener((view1, checkId) -> { + switch (checkId) { + case R.id.tv_simulate_text_show_hide: + break; + case R.id.tv_simulate_text_show_all: + break; + case R.id.tv_simulate_text_show_four: + break; + } + }); + + tvSimulatePointerStyle0.setOnClickListener((e) -> simulateViewModel.setPointerTypeName(DefaultPointer.TYPE_NAME)); + tvSimulatePointerStyle1.setOnClickListener((e) -> simulateViewModel.setPointerTypeName(LeafPointer.TYPE_LEAF)); + tvSimulatePointerStyle2.setOnClickListener((e) -> simulateViewModel.setPointerTypeName(LeafTwoPointer.TYPE_LEAF_TWO)); + tvSimulatePointerStyle3.setOnClickListener((e) -> simulateViewModel.setPointerTypeName(SecondTailPointer.TYPE_SECOND_TAIL)); + tvSimulatePointerStyle4.setOnClickListener((e) -> simulateViewModel.setPointerTypeName(SwordPointer.TYPE_SWORD_POINTER)); + tvSimulatePointerStyle5.setOnClickListener((e) -> simulateViewModel.setPointerTypeName(TrianglePointer.TYPE_TRIANGLE_POINTER)); + tvSimulatePointerStyle6.setOnClickListener((e) -> simulateViewModel.setPointerTypeName(TwoStepPointer.TYPE_TWO_STEP_POINTER)); + + + tvSimulateColorPointer.setOnClickListener((view1) -> { + colorSelect(simulateViewModel.getSimulateClockColorPointer().getValue(), + new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + simulateViewModel.setSimulateClockColorPointer(color); + view1.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + }); + + tvSimulateColorPointerSecond.setOnClickListener((view1) -> { + colorSelect(simulateViewModel.getSimulateClockColorPointerSecond().getValue(), + new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + simulateViewModel.setSimulateClockColorPointerSecond(color); + view1.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + }); + + tvSimulateColorScale.setOnClickListener((view1) -> { + colorSelect(simulateViewModel.getSimulateClockColorScale().getValue(), + new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + simulateViewModel.setSimulateClockColorScale(color); + view1.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + }); + + tvSimulateColorScalepParticularly.setOnClickListener((view1) -> { + colorSelect(simulateViewModel.getSimulateClockColorScaleParticularly().getValue(), + new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + simulateViewModel.setSimulateClockColorScaleParticularly(color); + view1.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + }); + + tvSimulateColorOutline.setOnClickListener((view1) -> { + colorSelect(simulateViewModel.getSimulateClockColorOutLine().getValue(), + new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + simulateViewModel.setSimulateClockColorOutLine(color); + view1.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + }); + + tvSimulateColorText.setOnClickListener((view1) -> { + colorSelect(simulateViewModel.getSimulateClockColorText().getValue(), + new ColorPickerPop.OnColorListener() { + @Override + public void onEnsure(int color) { + simulateViewModel.setSimulateClockColorText(color); + view1.setBackgroundColor(color); + } + + @Override + public void onBack() { + } + }); + }); + + return view; + } + + private void colorSelect(int defColor, ColorPickerPop.OnColorListener listener){ + if (colorPickerDialog == null) + colorPickerDialog = new ColorPickerPop(getActivity()); + colorPickerDialog.setOnColorChangeListenter(listener); + colorPickerDialog.show(defColor); + } + + + private void bindViewModel() { + + } + + /** + * onDestroyView中进行解绑操作 + */ + @Override + public void onDestroyView() { + super.onDestroyView(); + unbinder.unbind(); + } +} diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockFragment.java index d1faa63..d70708e 100644 --- a/app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockFragment.java +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/SimulateClockFragment.java @@ -69,17 +69,14 @@ public class SimulateClockFragment extends Fragment { @Override public void onResume() { super.onResume(); - if(clockAnimator!=null){ - clockAnimator.start(); - } + clockAnimator.start(); + } @Override public void onPause() { super.onPause(); - if(clockAnimator!=null){ - clockAnimator.stop(); - } + clockAnimator.stop(); } private void bindViewModel(){ @@ -103,44 +100,30 @@ public class SimulateClockFragment extends Fragment { clockAnimator.setColor(integer); } }); + + simulateViewModel.getSimulateClockColorOutLine().observe(this,color->clockAnimator.setmClockColor(color)); + + simulateViewModel.getSimulateClockColorPointer().observe(this,color->clockAnimator.setmClockColorPointer(color)); + + simulateViewModel.getSimulateClockColorPointerSecond().observe(this,color->clockAnimator.setPointerSecondColor(color)); + + simulateViewModel.getSimulateClockColorScale().observe(this,color->clockAnimator.setmColorDefaultScale(color)); + + simulateViewModel.getSimulateClockColorScaleParticularly().observe(this,color->clockAnimator.setmColorParticularyScale(color)); } ClockAnimator clockAnimator=null; - private void changeFullScreenClock(int index) { - Log.d(TAG,"changeFullScreenClock index:"+index); - - clockAnimator.setColor(globalViewModel.getForegroundColor().getValue()); - - switch (index) { - case 1: - clockAnimator.setClock(new SquareClock()); - break; - case 2: - clockAnimator.setClock(new OvalClock()); - break; - case 3: - clockAnimator.setClock(new CircleTwoClock()); - break; - case 4: - clockAnimator.setClock(new HexagonalClock()); - break; - case 5: - clockAnimator.setClock(new HelixClock()); - break; - default: - clockAnimator.setClock(new CircleClock()); - } - clockView.setAnimator(clockAnimator); - } private void setFullScreenClock(String clockStyle,String pointerStyle){ setClockStyle(clockStyle); setClockPointer(pointerStyle); } + AbstractClock clock; + private void setClockStyle(String clockStyle){ clockAnimator.setColor(globalViewModel.getForegroundColor().getValue()); - AbstractClock clock= ClockFactory.build(clockStyle); + clock= ClockFactory.build(clockStyle); clockAnimator.setClock(clock); } diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUIDefaultFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUIDefaultFragment.java new file mode 100644 index 0000000..153659b --- /dev/null +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUIDefaultFragment.java @@ -0,0 +1,18 @@ +package clock.socoolby.com.clock.fragment; + +import clock.socoolby.com.clock.R; + +public class ThemeUIDefaultFragment extends AbstractThemeUIFragment { + + public static final String THEME_NAME="default"; + + public ThemeUIDefaultFragment() { + super(R.layout.theme_default); + } + + @Override + void changeThemeTypeCheck() { + themeUIViewModel.getThemeName().setValue(ThemeUISampleFragment.THEME_NAME); + } + +} diff --git a/app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUISampleFragment.java b/app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUISampleFragment.java new file mode 100644 index 0000000..fb865aa --- /dev/null +++ b/app/src/main/java/clock/socoolby/com/clock/fragment/ThemeUISampleFragment.java @@ -0,0 +1,17 @@ +package clock.socoolby.com.clock.fragment; + +import clock.socoolby.com.clock.R; + +public class ThemeUISampleFragment extends AbstractThemeUIFragment { + + public static final String THEME_NAME="sample"; + + public ThemeUISampleFragment() { + super(R.layout.theme_sample); + } + + @Override + void changeThemeTypeCheck() { + themeUIViewModel.getThemeName().setValue(ThemeUIDefaultFragment.THEME_NAME); + } +} diff --git a/app/src/main/java/clock/socoolby/com/clock/model/SharePerferenceModel.java b/app/src/main/java/clock/socoolby/com/clock/model/SharePerferenceModel.java index 7fab293..d376d94 100755 --- a/app/src/main/java/clock/socoolby/com/clock/model/SharePerferenceModel.java +++ b/app/src/main/java/clock/socoolby/com/clock/model/SharePerferenceModel.java @@ -14,6 +14,7 @@ import clock.socoolby.com.clock.ClockApplication; import clock.socoolby.com.clock.Constants; import clock.socoolby.com.clock.R; import clock.socoolby.com.clock.utils.FileUtils; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.SimulateTextShowTypeEnum; public class SharePerferenceModel implements Serializable { @@ -65,6 +66,9 @@ public class SharePerferenceModel implements Serializable { protected final static String KEY_HANDUP_MUSIC ="key_handup_music"; protected String handUpMusic = ""; + protected final static String KEY_HANDUP_DIALY="key_handup_dialy"; + protected Integer handUpDialy=60; + protected final static String KEY_BACKGROUND_COLOR="key_background_color"; protected Integer backgroundColor=Color.rgb(0, 0, 0); @@ -114,6 +118,28 @@ public class SharePerferenceModel implements Serializable { protected final static String KEY_SIMULATE_CLOCK_POINTER_TYPE_NAME="key_simulate_clock_pointer_type_name"; protected String simulateClockPointerTypeName; + + protected final static String KEY_SIMULATE_CLOCK_COLOR_SCALE="key_simulate_clock_color_scale"; + protected Integer simulateClockColorScale; + + protected final static String KEY_SIMULATE_CLOCK_COLOR_SCALE_PARTICULARLY="key_simulate_clock_color_scale_particularly"; + protected Integer simulateClockColorScaleParticularly; + + protected final static String KEY_SIMULATE_CLOCK_COLOR_TEXT="key_simulate_clock_color_text"; + protected Integer simulateClockColorText; + + protected final static String KEY_SIMULATE_CLOCK_COLOR_POINTER="key_simulate_clock_color_pointer"; + protected Integer simulateClockColorPointer; + + protected final static String KEY_SIMULATE_CLOCK_COLOR_POINTER_SECOND="key_simulate_clock_color_pointer_second"; + protected Integer simulateClockColorPointerSecond; + + protected final static String KEY_SIMULATE_CLOCK_COLOR_OUTLINE="key_simulate_clock_color_outLine"; + protected Integer simulateClockColorOutLine; + + protected final static String KEY_SIMULATE_CLOCK_TEXT_SHOW_TYPE="key_simulate_clock_text_show_type"; + protected Integer simulateClockTextShowType; + //ui protected final static String KEY_UI_CLOCK_INTERFACE_TYPE ="key_ui_clock_interface_type"; protected int clockInterfaceType; @@ -293,6 +319,7 @@ public class SharePerferenceModel implements Serializable { handUpAble=jsonObject.optBoolean(KEY_IS_HANDUP_ABLE,false); handUpTime=jsonObject.optInt(KEY_HANDUP_TIME,-1); handUpMusic=jsonObject.optString(KEY_HANDUP_MUSIC,""); + handUpDialy=jsonObject.optInt(KEY_HANDUP_DIALY,60); backgroundColor=jsonObject.optInt(KEY_BACKGROUND_COLOR,Color.rgb(0, 0, 0)); backgroundImage=jsonObject.optString(KEY_BACKGROUND_IMAGE,""); @@ -311,9 +338,15 @@ public class SharePerferenceModel implements Serializable { timeTextCharAnimatorType=jsonObject.optInt(KEY_TIME_TEXT_CHAR_ANIMATOR_TYPE,0); fontName=jsonObject.optString(KEY_FONT_NAME,"default"); - simulateClockTypeName=jsonObject.optString(KEY_SIMULATE_CLOCK_TYPE_NAME,"default"); simulateClockPointerTypeName=jsonObject.optString(KEY_SIMULATE_CLOCK_POINTER_TYPE_NAME,"default"); + simulateClockColorScale=jsonObject.optInt(KEY_SIMULATE_CLOCK_COLOR_SCALE,Color.rgb(255, 255, 255)); + simulateClockColorScaleParticularly=jsonObject.optInt(KEY_SIMULATE_CLOCK_COLOR_SCALE_PARTICULARLY,Color.rgb(255, 255, 255)); + simulateClockColorText=jsonObject.optInt(KEY_SIMULATE_CLOCK_COLOR_TEXT,Color.rgb(255, 255, 255)); + simulateClockColorOutLine=jsonObject.optInt(KEY_SIMULATE_CLOCK_COLOR_OUTLINE,Color.rgb(255, 255, 255)); + simulateClockTextShowType=jsonObject.optInt(KEY_SIMULATE_CLOCK_TEXT_SHOW_TYPE,0); + simulateClockColorPointer=jsonObject.optInt(KEY_SIMULATE_CLOCK_COLOR_POINTER,Color.rgb(255, 255, 255)); + simulateClockColorPointerSecond=jsonObject.optInt(KEY_SIMULATE_CLOCK_COLOR_POINTER_SECOND,Color.rgb(255, 255, 255)); themeName=jsonObject.optString(KEY_THEME_UI_NAME,"default"); @@ -345,7 +378,10 @@ public class SharePerferenceModel implements Serializable { jsonObject.put(KEY_DISPLAYVIEW_WEATHER, weatherLocation.toString()); jsonObject.put(KEY_DISPLAYVIEW_DESCRIPTION, descriptionLocation.toString()); jsonObject.put(KEY_FONT_INDEX, fontIndex); + jsonObject.put(KEY_HANDUP_TIME,handUpTime); + jsonObject.put(KEY_HANDUP_DIALY,handUpDialy); + jsonObject.put(KEY_IS_HANDUP_ABLE,handUpAble); jsonObject.put(KEY_HANDUP_MUSIC,handUpMusic); jsonObject.put(KEY_BACKGROUND_COLOR,backgroundColor); @@ -368,6 +404,14 @@ public class SharePerferenceModel implements Serializable { jsonObject.put(KEY_SIMULATE_CLOCK_TYPE_NAME,simulateClockTypeName); jsonObject.put(KEY_SIMULATE_CLOCK_POINTER_TYPE_NAME,simulateClockPointerTypeName); + jsonObject.put(KEY_SIMULATE_CLOCK_COLOR_SCALE,simulateClockColorScale); + jsonObject.put(KEY_SIMULATE_CLOCK_COLOR_SCALE_PARTICULARLY,simulateClockColorScaleParticularly); + jsonObject.put(KEY_SIMULATE_CLOCK_COLOR_TEXT,simulateClockColorText); + jsonObject.put(KEY_SIMULATE_CLOCK_COLOR_OUTLINE,simulateClockColorOutLine); + jsonObject.put(KEY_SIMULATE_CLOCK_TEXT_SHOW_TYPE,simulateClockTextShowType); + jsonObject.put(KEY_SIMULATE_CLOCK_COLOR_POINTER,simulateClockColorPointer); + jsonObject.put(KEY_SIMULATE_CLOCK_COLOR_POINTER_SECOND,simulateClockColorPointerSecond); + jsonObject.put(KEY_THEME_UI_NAME,themeName); jsonObject.put(KEY_UI_CLOCK_INTERFACE_TYPE, clockInterfaceType); @@ -526,6 +570,15 @@ public class SharePerferenceModel implements Serializable { dirtySave(); } + public Integer getHandUpDialy() { + return handUpDialy; + } + + public void setHandUpDialy(Integer handUpDialy) { + this.handUpDialy = handUpDialy; + dirtySave(); + } + public String getBackgroundImage() { return backgroundImage; } @@ -662,4 +715,68 @@ public class SharePerferenceModel implements Serializable { this.autoFullscreen = autoFullscreen; dirtySave(); } + + + public Integer getSimulateClockColorScale() { + return simulateClockColorScale; + } + + public void setSimulateClockColorScale(Integer simulateClockColorScale) { + this.simulateClockColorScale = simulateClockColorScale; + dirtySave(); + } + + public Integer getSimulateClockColorScaleParticularly() { + return simulateClockColorScaleParticularly; + } + + public void setSimulateClockColorScaleParticularly(Integer simulateClockColorScaleParticularly) { + this.simulateClockColorScaleParticularly = simulateClockColorScaleParticularly; + dirtySave(); + } + + public Integer getSimulateClockColorText() { + return simulateClockColorText; + } + + public void setSimulateClockColorText(Integer simulateClockColorText) { + this.simulateClockColorText = simulateClockColorText; + dirtySave(); + } + + public Integer getSimulateClockColorOutLine() { + return simulateClockColorOutLine; + } + + public void setSimulateClockColorOutLine(Integer simulateClockColorOutLine) { + this.simulateClockColorOutLine = simulateClockColorOutLine; + dirtySave(); + } + + public Integer getSimulateClockTextShowType() { + return simulateClockTextShowType; + } + + public void setSimulateClockTextShowType(Integer simulateClockTextShowType) { + this.simulateClockTextShowType = simulateClockTextShowType; + dirtySave(); + } + + public Integer getSimulateClockColorPointer() { + return simulateClockColorPointer; + } + + public void setSimulateClockColorPointer(Integer simulateClockColorPointer) { + this.simulateClockColorPointer = simulateClockColorPointer; + dirtySave(); + } + + public Integer getSimulateClockColorPointerSecond() { + return simulateClockColorPointerSecond; + } + + public void setSimulateClockColorPointerSecond(Integer simulateClockColorPointerSecond) { + this.simulateClockColorPointerSecond = simulateClockColorPointerSecond; + dirtySave(); + } } diff --git a/app/src/main/java/clock/socoolby/com/clock/state/ClockStateMachine.java b/app/src/main/java/clock/socoolby/com/clock/state/ClockStateMachine.java index 426c101..3f5482f 100644 --- a/app/src/main/java/clock/socoolby/com/clock/state/ClockStateMachine.java +++ b/app/src/main/java/clock/socoolby/com/clock/state/ClockStateMachine.java @@ -6,6 +6,7 @@ import android.util.Log; import com.haibin.calendarview.LunarCalendarManager; +import java.sql.Time; import java.util.Date; import java.util.Timer; import java.util.TimerTask; @@ -18,11 +19,14 @@ import clock.socoolby.com.clock.model.DateModel; import clock.socoolby.com.clock.model.SharePerferenceModel; import clock.socoolby.com.clock.utils.Player; import clock.socoolby.com.clock.utils.ScreenManager; +import clock.socoolby.com.clock.viewmodel.AlterViewModel; import clock.socoolby.com.clock.viewmodel.DigitViewModel; import clock.socoolby.com.clock.viewmodel.GlobalViewModel; import clock.socoolby.com.clock.viewmodel.SimulateViewModel; import clock.socoolby.com.clock.viewmodel.ThemeUIViewModel; +import static clock.socoolby.com.clock.state.ClockTimeTypeEnum.TIME; + public class ClockStateMachine implements Handler.Callback{ public static final String TAG=ClockStateMachine.class.getSimpleName(); @@ -31,6 +35,7 @@ public class ClockStateMachine implements Handler.Callback{ DigitViewModel digitViewModel; SimulateViewModel simulateViewModel; ThemeUIViewModel themeUIViewModel; + AlterViewModel alterViewModel; private Timer timer; private Handler handler; @@ -45,16 +50,18 @@ public class ClockStateMachine implements Handler.Callback{ boolean heartbeat=false; - ClockTimeTypeEnum showTimeType=ClockTimeTypeEnum.TIME; + ClockTimeTypeEnum showTimeType= TIME; - public ClockStateMachine(AlterManager alterManager,GlobalViewModel globalViewModel, DigitViewModel digitViewModel, SimulateViewModel simulateViewModel,ThemeUIViewModel themeUIViewModel) { + public ClockStateMachine(AlterManager alterManager,GlobalViewModel globalViewModel, DigitViewModel digitViewModel, SimulateViewModel simulateViewModel,ThemeUIViewModel themeUIViewModel,AlterViewModel alterViewModel) { this.globalViewModel = globalViewModel; this.digitViewModel = digitViewModel; this.simulateViewModel = simulateViewModel; this.alterManager = alterManager; + this.alterViewModel=alterViewModel; this.themeUIViewModel=themeUIViewModel; } + public void start(){ LunarCalendarManager.init(ClockApplication.getContext()); model=ClockApplication.getInstance().getModel(); @@ -71,9 +78,7 @@ public class ClockStateMachine implements Handler.Callback{ } }; timer.schedule(timerTask, 1000, 1000); - } - - + } @Override public boolean handleMessage(Message msg) { @@ -87,49 +92,32 @@ public class ClockStateMachine implements Handler.Callback{ } public void setCurrentShowTimeType(ClockTimeTypeEnum type){ + if(getCurrentModeEnum()==ClockModeEnum.HANDUP) + stopHandUp(true); + else if(getCurrentModeEnum()==ClockModeEnum.DELAY) + stopHandUpDelay(); + this.showTimeType=type; + countingDateTimeBase=null; switch (type){ case COUNTING: countingDateTimeBase =new Date(); } } - private int handUPDialy=60; - - private void checkHandUp(){ - /*if(!handUpAbla) { - return; - } - //Log.d(TAG,"checkHandUp..\thandUPDialy:"+handUPDialy+" \thandUpTime:"+handUpTime+"\thandUpAble:"+handUpAbla); - if(mMode==MODE_HANDUP) { - tv_handup_image.setText("hand up:"+handUPDialy); - handUPDialy--; - if(handUPDialy==0) { - switchMode(MODE_NORMAL); - if(!isArtificialHiddle&&showTimeType==ShowTimeType.TIME){ - setCurrentShowTimeType(ShowTimeType.COUNTING); - } - }else - Player.valueOf().playHandUp(this); - return; - } - handUpTime--; - if(hand_time_visable) - tv_hand_time.setText(DateModel.getTime(handUpTime)); - if (handUpTime <= 10&&handUpTime > 0) - setDiscript("提醒时间倒计时： " + handUpTime); - if (handUpTime == 0) { - handUPDialy = 60; - resetHandUpTime(); - switchMode(MODE_HANDUP); - }*/ + public ClockTimeTypeEnum getCurrentShowTimeType(){ + return showTimeType; } + private ClockModeEnum getCurrentModeEnum(){ + return globalViewModel.getClockModeEnum().getValue(); + } + private void updateTime() { heartbeat=!heartbeat; DateModel date = new DateModel(); String timeString=null; - switch (globalViewModel.getClockModeEnum().getValue()){ + switch (getCurrentModeEnum()){ case NORMAL: switch (showTimeType){ case COUNTING: @@ -140,7 +128,7 @@ public class ClockStateMachine implements Handler.Callback{ } break; case COUNTING_DOWN: - //timeString=DateModel.getTimeFull(handUpTime); + timeString=DateModel.getTimeFull(globalViewModel.getHandUpTime().getValue()); break; default: timeString = model.isDisplaySecond() ? date.getTimeString(model.isHourSystem12()) : date.getShortTimeString(heartbeat,model.isHourSystem12()); @@ -149,10 +137,15 @@ public class ClockStateMachine implements Handler.Callback{ digitViewModel.getTimeText().setValue(timeString); break; case HANDUP: - + globalViewModel.setHeartbeat(heartbeat); break; case DELAY: - + DateModel temp=new DateModel(countingDateTimeBase); + timeString=temp.getTimeString(false); + if (!model.isTickSound()) { + Player.getInstance().playTick(ClockApplication.getContext(), R.raw.tick2); + } + digitViewModel.getTimeText().setValue(timeString); break; } reportTime(date); @@ -224,4 +217,64 @@ public class ClockStateMachine implements Handler.Callback{ public void onDestory() { timer.cancel(); } + + + //handUp + public void stopHandUp(boolean userCheckStop){ + if(!userCheckStop&&showTimeType==TIME){ + globalViewModel.getClockModeEnum().setValue(ClockModeEnum.DELAY); + }else + globalViewModel.getClockModeEnum().setValue(ClockModeEnum.NORMAL); + } + + public void stopHandUpDelay(){ + globalViewModel.getClockModeEnum().setValue(ClockModeEnum.NORMAL); + } + + public void handUpCountingDownCheck(){ + if(isHandUpAbla()){ + if(showTimeType==ClockTimeTypeEnum.COUNTING_DOWN) + setCurrentShowTimeType(TIME); + else + setCurrentShowTimeType(ClockTimeTypeEnum.COUNTING_DOWN); + } + } + + public void countingCheck(){ + if(showTimeType!= ClockTimeTypeEnum.COUNTING){ + setCurrentShowTimeType(ClockTimeTypeEnum.COUNTING); + }else{ + setCurrentShowTimeType(ClockTimeTypeEnum.TIME); + } + } + + private boolean isHandUpAbla(){ + return globalViewModel.getHandUpAble().getValue(); + } + + private void checkHandUp(){ + if(!isHandUpAbla()) { + return; + } + int handUpTime=globalViewModel.getHandUpTime().getValue(); + switch (getCurrentModeEnum()) { + case NORMAL: + globalViewModel.getHandUpTime().setValue(handUpTime-1); + if (handUpTime <= 10&&handUpTime > 0) + themeUIViewModel.setDescription("提醒时间倒计时： " + handUpTime); + if (handUpTime == 0) { + globalViewModel.getHandUpTime().setValue(model.getHandUpTime()); + globalViewModel.getClockModeEnum().setValue(ClockModeEnum.HANDUP); + themeUIViewModel.setDescription(model.getDescription()); + } + break; + case HANDUP: + + break; + case DELAY: + if(countingDateTimeBase==null) + countingDateTimeBase =new Date(); + break; + } + } } diff --git a/app/src/main/java/clock/socoolby/com/clock/viewmodel/AlterViewModel.java b/app/src/main/java/clock/socoolby/com/clock/viewmodel/AlterViewModel.java index b5ce6a5..653f2cb 100644 --- a/app/src/main/java/clock/socoolby/com/clock/viewmodel/AlterViewModel.java +++ b/app/src/main/java/clock/socoolby/com/clock/viewmodel/AlterViewModel.java @@ -15,7 +15,6 @@ public class AlterViewModel extends ViewModel { private MutableLiveData handUPDialy=new MutableLiveData<>(); //alter handUp UI - private MutableLiveData handUpDescription=new MutableLiveData<>(); SharePerferenceModel model; @@ -25,20 +24,16 @@ public class AlterViewModel extends ViewModel { } public void loadFromModel(){ - String handUpMusicString=model.getHandUpMusic(); Uri musicUri=handUpMusicString.isEmpty()?null:Uri.parse(handUpMusicString); handUpMusic.setValue(musicUri); + handUPDialy.setValue(model.getHandUpDialy()); } public MutableLiveData getHandUpMusic() { return handUpMusic; } - public MutableLiveData getHandUpDescription() { - return handUpDescription; - } - public MutableLiveData getHandUPDialy() { return handUPDialy; } diff --git a/app/src/main/java/clock/socoolby/com/clock/viewmodel/DigitViewModel.java b/app/src/main/java/clock/socoolby/com/clock/viewmodel/DigitViewModel.java index 35aad47..0462592 100644 --- a/app/src/main/java/clock/socoolby/com/clock/viewmodel/DigitViewModel.java +++ b/app/src/main/java/clock/socoolby/com/clock/viewmodel/DigitViewModel.java @@ -113,8 +113,9 @@ public class DigitViewModel extends ViewModel { model.setTimeColorsArray(timeLinearGradientColorsArray); } - public void setReflectedAble(MutableLiveData reflectedAble) { - this.reflectedAble = reflectedAble; + public void setReflectedAble(Boolean reflectedAble) { + this.reflectedAble.setValue(reflectedAble); + model.setReflectedAble(reflectedAble); } public void setTimeFontStyleSize(Integer timeFontStyleSize) { diff --git a/app/src/main/java/clock/socoolby/com/clock/viewmodel/GlobalViewModel.java b/app/src/main/java/clock/socoolby/com/clock/viewmodel/GlobalViewModel.java index 3c42413..d552d14 100644 --- a/app/src/main/java/clock/socoolby/com/clock/viewmodel/GlobalViewModel.java +++ b/app/src/main/java/clock/socoolby/com/clock/viewmodel/GlobalViewModel.java @@ -40,6 +40,8 @@ public class GlobalViewModel extends ViewModel { private MutableLiveData brightness=new MutableLiveData<>(); + public MutableLiveData heartbeat=new MutableLiveData(); + //alter handUp private MutableLiveData handUpTime=new MutableLiveData<>(); @@ -65,6 +67,7 @@ public class GlobalViewModel extends ViewModel { public void loadFromModel(){ srceenLock.setValue(false); brightness.setValue(100); + heartbeat.setValue(true); mCity.setValue(model.getCity()); backgroundColor.setValue(model.getBackgroundColor()); @@ -85,6 +88,8 @@ public class GlobalViewModel extends ViewModel { handUpAble.setValue(model.isHandUpAble()); handUpTime.setValue(model.getHandUpTime()); + + hourSystem12.setValue(model.isHourSystem12()); } public MutableLiveData getCity() { @@ -164,6 +169,7 @@ public class GlobalViewModel extends ViewModel { return handUpAble; } + public void setCity(String mCity) { this.mCity.setValue(mCity); model.setCity(mCity); @@ -246,11 +252,19 @@ public class GlobalViewModel extends ViewModel { public void setHandUpTime(Integer handUpTime) { this.handUpTime.setValue(handUpTime); - model.setHandUpTime(handUpTime); + //model.setHandUpTime(handUpTime); } public void setHandUpAble(Boolean handUpAble) { this.handUpAble.setValue(handUpAble); model.setHandUpAble(handUpAble); } + + public MutableLiveData getHeartbeat() { + return heartbeat; + } + + public void setHeartbeat(Boolean heartbeat) { + this.heartbeat.setValue(heartbeat); + } } diff --git a/app/src/main/java/clock/socoolby/com/clock/viewmodel/SimulateViewModel.java b/app/src/main/java/clock/socoolby/com/clock/viewmodel/SimulateViewModel.java index 55966f2..c18a866 100644 --- a/app/src/main/java/clock/socoolby/com/clock/viewmodel/SimulateViewModel.java +++ b/app/src/main/java/clock/socoolby/com/clock/viewmodel/SimulateViewModel.java @@ -4,6 +4,7 @@ import androidx.lifecycle.MutableLiveData; import androidx.lifecycle.ViewModel; import clock.socoolby.com.clock.model.SharePerferenceModel; +import clock.socoolby.com.clock.widget.animatorview.animator.clockanimator.SimulateTextShowTypeEnum; public class SimulateViewModel extends ViewModel { @@ -11,6 +12,18 @@ public class SimulateViewModel extends ViewModel { private MutableLiveData pointerTypeName=new MutableLiveData<>(); + private MutableLiveData simulateClockColorScale=new MutableLiveData<>(); + private MutableLiveData simulateClockColorScaleParticularly=new MutableLiveData<>(); + private MutableLiveData simulateClockColorText=new MutableLiveData<>(); + private MutableLiveData simulateClockColorOutLine=new MutableLiveData<>(); + + private MutableLiveData simulateClockColorPointer=new MutableLiveData<>(); + + private MutableLiveData simulateClockColorPointerSecond=new MutableLiveData<>(); + + private MutableLiveData simulateClockTextShowType=new MutableLiveData<>(); + + SharePerferenceModel model; public SimulateViewModel(SharePerferenceModel model) { @@ -21,6 +34,14 @@ public class SimulateViewModel extends ViewModel { private void loadFromModel(){ clockTypeName.setValue(model.getSimulateClockTypeName()); pointerTypeName.setValue(model.getSimulateClockPointerTypeName()); + + simulateClockColorScale.setValue(model.getSimulateClockColorScale()); + simulateClockColorScaleParticularly.setValue(model.getSimulateClockColorScaleParticularly()); + simulateClockColorText.setValue(model.getSimulateClockColorText()); + simulateClockColorOutLine.setValue(model.getSimulateClockColorOutLine()); + simulateClockTextShowType.setValue(SimulateTextShowTypeEnum.valueOf(model.getSimulateClockTextShowType())); + simulateClockColorPointer.setValue(model.getSimulateClockColorPointer()); + simulateClockColorPointerSecond.setValue(model.getSimulateClockColorPointerSecond()); } public MutableLiveData getClockTypeName() { @@ -40,4 +61,68 @@ public class SimulateViewModel extends ViewModel { this.pointerTypeName.setValue(pointerTypeName); model.setSimulateClockPointerTypeName(pointerTypeName); } + + public MutableLiveData getSimulateClockColorScale() { + return simulateClockColorScale; + } + + public void setSimulateClockColorScale(Integer simulateClockColorScale) { + this.simulateClockColorScale.setValue(simulateClockColorScale); + model.setSimulateClockColorScale(simulateClockColorScale); + } + + public MutableLiveData getSimulateClockColorScaleParticularly() { + return simulateClockColorScaleParticularly; + } + + public void setSimulateClockColorScaleParticularly(Integer simulateClockColorScaleParticularly) { + this.simulateClockColorScaleParticularly.setValue(simulateClockColorScaleParticularly); + model.setSimulateClockColorScaleParticularly(simulateClockColorScaleParticularly); + } + + public MutableLiveData getSimulateClockColorText() { + return simulateClockColorText; + } + + public void setSimulateClockColorText(Integer simulateClockColorText) { + this.simulateClockColorText.setValue(simulateClockColorText); + model.setSimulateClockColorText(simulateClockColorText); + } + + public MutableLiveData getSimulateClockColorOutLine() { + return simulateClockColorOutLine; + } + + public void setSimulateClockColorOutLine(Integer simulateClockColorOutLine) { + this.simulateClockColorOutLine.setValue(simulateClockColorOutLine); + model.setSimulateClockColorOutLine(simulateClockColorOutLine); + } + + public MutableLiveData getSimulateClockTextShowType() { + return simulateClockTextShowType; + } + + public void setSimulateClockTextShowType(SimulateTextShowTypeEnum simulateClockTextShowType) { + this.simulateClockTextShowType.setValue(simulateClockTextShowType); + model.setSimulateClockTextShowType(simulateClockTextShowType.code); + } + + + public MutableLiveData getSimulateClockColorPointer() { + return simulateClockColorPointer; + } + + public void setSimulateClockColorPointer(Integer simulateClockColorPointer) { + this.simulateClockColorPointer.setValue(simulateClockColorPointer); + model.setSimulateClockColorPointer(simulateClockColorPointer); + } + + public MutableLiveData getSimulateClockColorPointerSecond() { + return simulateClockColorPointerSecond; + } + + public void setSimulateClockColorPointerSecond(Integer simulateClockColorPointerSecond) { + this.simulateClockColorPointerSecond.setValue(simulateClockColorPointerSecond); + model.setSimulateClockColorPointerSecond(simulateClockColorPointerSecond); + } } diff --git a/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/ClockAnimator.java b/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/ClockAnimator.java index 0cc1b8d..4cb239b 100644 --- a/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/ClockAnimator.java +++ b/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/ClockAnimator.java @@ -21,8 +21,12 @@ public class ClockAnimator extends AbstractAnimator { AbstractClock clock; + // 时钟颜色、默认刻度颜色、时刻度颜色 + protected int mClockColor=Color.BLACK, mColorDefaultScale=Color.BLACK, mColorParticularyScale=Color.BLACK,textColor=Color.BLACK,mClockColorPointer=Color.BLACK,pointerSecondColor=Color.BLACK; + public ClockAnimator() { super(DYNAMIC_QUANTITY); + } @Override @@ -42,7 +46,16 @@ public class ClockAnimator extends AbstractAnimator { list.clear(); this.clock=clock1; int minHigh=Math.min(width,height); - clock.init(width,height,width/2,height/2,minHigh/2,color,color); + clock.init(width,height,width/2,height/2,minHigh/2,color,textColor); + + clock.setPointerSecondColor(pointerSecondColor); + clock.setmColorDefaultScale(mColorDefaultScale); + clock.setmColorParticularyScale(mColorParticularyScale); + clock.setTextColor(textColor); + clock.setmClockColorPointer(mClockColorPointer); + clock.setPointerSecondColor(pointerSecondColor); + clock.setmClockColor(mClockColor); + list.add(clock); Log.d("clock","set clock type: "+clock1.typeName()+"\t color:"+ color); } @@ -57,38 +70,37 @@ public class ClockAnimator extends AbstractAnimator { super.onSizeChanged(w, h, oldw, oldh); if(clock!=null) { int minHigh=Math.min(width,height); - clock.init(width, height, width / 2, height / 2, minHigh / 2, color, color); + clock.init(width, height, width / 2, height / 2, minHigh / 2, color, textColor); } } - int randPointerIndex=1; - public void randPointer(){ - if(clock==null) - return; - if(randPointerIndex>6) - randPointerIndex=0; - switch (randPointerIndex){ - case 1: - clock.setPointer(new SecondTailPointer()); - break; - case 2: - clock.setPointer(new TrianglePointer()); - break; - case 3: - clock.setPointer(new SwordPointer()); - break; - case 4: - clock.setPointer(new TwoStepPointer()); - break; - case 5: - clock.setPointer(new LeafPointer()); - break; - case 6: - clock.setPointer(new LeafTwoPointer()); - break; - default: - clock.setPointer(new DefaultPointer()); - } - randPointerIndex++; + public void setmClockColor(int mClockColor) { + this.mClockColor = mClockColor; + clock.setmClockColor(mClockColor); + } + + public void setmColorDefaultScale(int mColorDefaultScale) { + this.mColorDefaultScale = mColorDefaultScale; + clock.setmColorDefaultScale(mColorDefaultScale); + } + + public void setmColorParticularyScale(int mColorParticularyScale) { + this.mColorParticularyScale = mColorParticularyScale; + clock.setmColorParticularyScale(mColorParticularyScale); + } + + public void setTextColor(int textColor) { + this.textColor = textColor; + clock.setTextColor(textColor); + } + + public void setmClockColorPointer(int mClockColorPointer) { + this.mClockColorPointer = mClockColorPointer; + clock.setmClockColorPointer(mClockColorPointer); + } + + public void setPointerSecondColor(int pointerSecondColor) { + this.pointerSecondColor = pointerSecondColor; + clock.setPointerSecondColor(pointerSecondColor); } } diff --git a/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/AbstractClock.java b/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/AbstractClock.java index b043ef4..20ccf42 100644 --- a/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/AbstractClock.java +++ b/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/AbstractClock.java @@ -26,10 +26,13 @@ public abstract class AbstractClock implements I_AnimatorEntry { protected int mH, mM, mS; // 时钟颜色、默认刻度颜色、时刻度颜色 - protected int mClockColor, mColorDefaultScale, mColorParticularyScale,textColor; + protected int mClockColor, mColorDefaultScale, mColorParticularyScale,textColor,mClockColorPointer,pointerSecondColor; I_Pointer pointer; + SimulateTextShowTypeEnum simulateTextShowTypeEnum=SimulateTextShowTypeEnum.FOUR; + + public AbstractClock() { } @@ -55,6 +58,8 @@ public abstract class AbstractClock implements I_AnimatorEntry { private void init() { mColorDefaultScale = mClockColor; mColorParticularyScale = mClockColor; + mClockColorPointer=mClockColor; + pointerSecondColor=mClockColor; mDefaultPaint = new Paint(); mDefaultPaint.setAntiAlias(true); @@ -64,7 +69,7 @@ public abstract class AbstractClock implements I_AnimatorEntry { mTextPaint.setStrokeWidth(mDefaultScaleWidth / 2); mTextPaint.setTextSize(mParticularlyScaleWidth * 4); mTextPaint.setTextAlign(Paint.Align.CENTER); - mTextPaint.setColor(textColor); + //mTextPaint.setColor(textColor); } @@ -89,7 +94,8 @@ public abstract class AbstractClock implements I_AnimatorEntry { public void setPointer(I_Pointer pointer){ this.pointer=pointer; - pointer.init(mRadius,mClockColor); + pointer.init(mRadius,mClockColorPointer); + pointer.setColorSecond(pointerSecondColor); } @Override @@ -98,6 +104,64 @@ public abstract class AbstractClock implements I_AnimatorEntry { pointer.init(mRadius,mClockColor); } + public int getmColorDefaultScale() { + return mColorDefaultScale; + } + + public void setmColorDefaultScale(int mColorDefaultScale) { + this.mColorDefaultScale = mColorDefaultScale; + } + + public int getmColorParticularyScale() { + return mColorParticularyScale; + } + + public void setmColorParticularyScale(int mColorParticularyScale) { + this.mColorParticularyScale = mColorParticularyScale; + } + + public int getTextColor() { + return textColor; + } + + public void setTextColor(int textColor) { + this.textColor = textColor; + } + + public int getmClockColor() { + return mClockColor; + } + + public void setmClockColor(int mClockColor) { + this.mClockColor = mClockColor; + } + + public int getmClockColorPointer() { + return mClockColorPointer; + } + + public void setmClockColorPointer(int mClockColorPointer) { + this.mClockColorPointer = mClockColorPointer; + pointer.setmPointerColor(mClockColorPointer); + } + + public int getPointerSecondColor() { + return pointerSecondColor; + } + + public void setPointerSecondColor(int pointerSecondColor) { + this.pointerSecondColor = pointerSecondColor; + pointer.setColorSecond(pointerSecondColor); + } + + public SimulateTextShowTypeEnum getSimulateTextShowTypeEnum() { + return simulateTextShowTypeEnum; + } + + public void setSimulateTextShowTypeEnum(SimulateTextShowTypeEnum simulateTextShowTypeEnum) { + this.simulateTextShowTypeEnum = simulateTextShowTypeEnum; + } + /** * 获取当前系统时间 */ @@ -124,11 +188,15 @@ public abstract class AbstractClock implements I_AnimatorEntry { public void onDraw(Canvas canvas, Paint mPaint) { + drawBorder(canvas); + drawOrnament(canvas); // 坐标原点移动到View 中心 canvas.translate(mCenterX, mCenterY); + mPaint.setColor(textColor); drawText(canvas); + mPaint.setColor(mClockColorPointer); pointer.drawPointer(canvas,mH,mM,mS,mPaint); } @@ -221,6 +289,7 @@ public abstract class AbstractClock implements I_AnimatorEntry { fontWidth = mTextPaint.measureText(h); // y轴坐标为: -（半径-特殊刻度长度-特殊刻度宽度（作为间距）-文字长度/2（绘制原点在文字横向中心）） y = -(mRadius - mParticularlyScaleLength - mParticularlyScaleWidth - (fontWidth / 2)); + canvas.drawText(h, y, 0 + offsetY, mTextPaint); } diff --git a/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/ClockFactory.java b/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/ClockFactory.java index 69840cd..2734dc0 100644 --- a/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/ClockFactory.java +++ b/app/src/main/java/clock/socoolby/com/clock/widget/animatorview/animator/clockanimator/ClockFactory.java @@ -31,4 +31,26 @@ public class ClockFactory { } return clock; } + + public static final String[] CLOCKS_ARRAY=new String[]{ + CircleClock.TYPE_CIRCLE, + CircleTwoClock.TYPE_CIRCLE_TWO, + HelixClock.TYPE_HELIX, + HexagonalClock.TYPE_HEXAGONAL, + OctagonalClock.TYPE_OCTAGONAL, + OvalClock.TYPE_OVAL, + SquareClock.TYPE_SQUARE + }; + + public static String nextSimulateClockName(String currentName){ + int order=0; + for(int i=0;i7){ - float fontScale = getResources().getDisplayMetrics().scaledDensity; + fontScale = getResources().getDisplayMetrics().scaledDensity; smallCharPaint = getCustomTextPaint(mTextPaint,mTextPaint.getTextSize()/fontScale*4/5); smallCharWidth=getCharWidth("8",smallCharPaint); fm=smallCharPaint.getFontMetricsInt(); @@ -190,19 +207,20 @@ public class DigitTextView extends androidx.appcompat.widget.AppCompatTextView { textSmallSpan=smallCharWidth*2; } - float startX=(getWidth()-textWidth-textSmallSpan)/2; - float startY=(getHeight()+textHight)/2; + startX=(getWidth()-textWidth-textSmallSpan)/2; + startY=(getHeight()+textHight)/2; - AbstractCharAnimator charAnimator; + if(linearGradientReCreate) + checkReCreate(); for(int i=0;i + + \ No newline at end of file diff --git a/app/src/main/res/layout/fragment_alter.xml b/app/src/main/res/layout/fragment_alter.xml index 82aa4e4..025597a 100644 --- a/app/src/main/res/layout/fragment_alter.xml +++ b/app/src/main/res/layout/fragment_alter.xml @@ -14,7 +14,6 @@ android:text='"hand up"' android:textColor="#fff" android:background="#00FFFFFF" - android:textSize="80sp" - android:visibility="gone" /> + android:textSize="80sp" /> \ No newline at end of file diff --git a/app/src/main/res/layout/fragment_digit_config.xml b/app/src/main/res/layout/fragment_digit_config.xml new file mode 100644 index 0000000..cd09d62 --- /dev/null +++ b/app/src/main/res/layout/fragment_digit_config.xml @@ -0,0 +1,225 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +