Android Studio多功能闹钟[android源码]

已于 2022-11-26 09:55:10 修改
阅读量1.3w 收藏 217
点赞数 29
分类专栏： Android 文章标签： 安卓 android java 移动开发
于 2019-12-20 23:37:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44138925/article/details/103639939
版权

Android Studio多功能闹钟[android源码]

多功能闹钟App

简 介

此多功能闹钟界面采用TabHost框架，头部包含分别用LinearLayout水平布局显示四个标签闹钟，时钟，计时器和秒表，FrameLayout框架内部采用LinearLayout垂直布局。功能事件的基本实现分别有AlarmView类，AlarmReceiver类，PlayAlarmAty类， TimeView类和StopWatch类完成。

主 要 技 术

此多功能闹钟界面采用TabHost 框架，头部包含分别用LinearLayout水平布局显示四个标签闹钟，时钟，计时器和秒表，FrameLayout框架内部采用LinearLayout垂直布局。功能事件的基本实现分别有AlarmView类，AlarmReceiver类，PlayAlarmAty类， TimeView类和StopWatch类完成。：

  1. 闹钟界面的界面设计 ，闹钟界面使用一个Button按钮和ListvView，设置的闹钟由ListView的Item项来呈现出来；开始按钮设置监听，当点击添加闹钟按钮时触发按钮监听引用TimePickerDialog将弹出一个设置时间对话框，当设置时间后点击ok按钮将触发监听中添加saveAlarmList()存储方法保存数据；闹钟功能使用SharedPreferences类存取数据，使用创建的saveAlarmList()存储方法和readSavedAlarmList()读取方法来实现闹钟设定数据的存取，使用创建AlarmData工具类进行数据存放。闹钟的设置及具体的响应采用AlarmView类，AlarmReceiver类和PlayAlarmAty类；AlarmView类中通过listview的setOnItemLongClickListener方法监听每个Item项，当检测到长按水平弹出到闹钟的操作对话框，通过弹出对话框中setNegativeButton按钮，删除Item项目闹钟；闹钟响铃通过AlarmManager的实例对象，根据我们设定时间来实现响铃。该闹钟是利用了页面跳转来实现的响铃，通过getActivity()方法来获取PendingIntent对象，将设定好的时间通过数据跳转到响铃的页面，通过弹出一个提示对话框和mediaPlayer 组件播放音乐来实现响铃功能。
  2. 时钟功能的实现简单引用了DigitalClock 显示时钟时间。
  3. 计时器功能具体实现是通过TimerView类来实现的，类中设置了开始,暂停和重置方法，然后监听开始，暂停，重置按钮来引用对应方法来实现计时器的计时功能，计时时间到采用Handle机制来新建一个对话框提醒时间到。
  4. 秒表的具体实现通过StopWatch 类来实现，类中设置了开始，暂停，复位和重置按钮的监听，监听直接引用了Chronometer 的start，stop，setBase和setFormat等方法实现秒表的功能。

界面截图

在这里插入图片描述

主要代码

主页面，MainActivity 代码.

// An highlighted block
public class MainActivity extends Activity {
    private TabHost tabHost;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        tabHost=(TabHost)findViewById(android.R.id.tabhost);
        tabHost.setup();

        tabHost.addTab(tabHost.newTabSpec("tabAlarm").setIndicator("闹钟").setContent(R.id.tabAlarm));
        tabHost.addTab(tabHost.newTabSpec("tabTime").setIndicator("时钟").setContent(R.id.tabTime));
        tabHost.addTab(tabHost.newTabSpec("tabTimer").setIndicator("计时器").setContent(R.id.tabTimer));
        tabHost.addTab(tabHost.newTabSpec("tabStopWatch").setIndicator("秒表").setContent(R.id.tabStopWatch));
    }
}

主页面，PlayAlarmAty 代码.

// An highlighted block
public class PlayAlarmAty extends Activity {
    private MediaPlayer mp;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mp = MediaPlayer.create(this,R.raw.clockmusic2);
        mp.start();
        new AlertDialog.Builder(PlayAlarmAty.this)
                .setIcon(R.mipmap.ic_launcher)
                .setTitle("闹钟")
                .setMessage("快完成你制定的计划吧!!!")
                .setNegativeButton("关闭", new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        PlayAlarmAty.this.finish();
                        mp.stop();
                    }
                })
                .show();
    }
    @Override
    protected void onPause(){
        super.onPause();
        finish();
    }
    protected void onDestroy(){
        super.onDestroy();
        mp.stop();
        mp.release();
    }
}

主页面，AlarmView 代码.

// An highlighted block
public class AlarmView extends LinearLayout {

    public AlarmView(Context context,AttributeSet attrs,int defStyle){
        super(context,attrs,defStyle);
        init();
    }
    public AlarmView(Context context,AttributeSet attrs){
        super(context,attrs);
        init();
    }
    public AlarmView(Context context ){
        super(context);
        init();
    }
    private void init(){
        alarmManager= (AlarmManager) getContext().getSystemService(Context.ALARM_SERVICE);
    }

    @Override
    protected void onFinishInflate(){
        super.onFinishInflate();

        btAddAlarm=(Button) findViewById(R.id.btnAddAlarm);
        lvAlarmList=(ListView) findViewById(R.id.lvAlarmList);

        adapter=new ArrayAdapter<AlarmData>(getContext(),android.R.layout.simple_list_item_1);
        lvAlarmList.setAdapter(adapter);
        readSavedAlarmList();

        btAddAlarm.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                addAlarm();
            }
        });

        lvAlarmList.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
            @Override
            public boolean onItemLongClick(AdapterView<?> parent, View view, final int position, long id) {
                new AlertDialog.Builder(getContext()).setTitle("操作").setItems(new CharSequence[]{"删除"}, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        switch (which){
                            case 0:
                                deleteAlarm(position);
                                break;
                            default:
                                break;
                        }
                    }
                }).setNegativeButton("取消",null).show();
                return true;
            }
        });
    }

    private void deleteAlarm(int position){
        AlarmData ad=adapter.getItem(position);
        adapter.remove(ad);
        saveAlarmList();   alarmManager.cancel(PendingIntent.getBroadcast(getContext(),ad.getId(),new Intent(getContext(),AlarmReceiver.class),0));
    }

    private void addAlarm(){
        Calendar c =Calendar.getInstance();
        new TimePickerDialog(getContext(), new TimePickerDialog.OnTimeSetListener() {
            @Override
            public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
                Calendar calendar=Calendar.getInstance();
                calendar.set(Calendar.HOUR_OF_DAY,hourOfDay);
                calendar.set(Calendar.MINUTE,minute);
                calendar.set(Calendar.SECOND,0);
                calendar.set(Calendar.MILLISECOND,0);

                Calendar currentTime=Calendar.getInstance();
                if (calendar.getTimeInMillis()<=currentTime.getTimeInMillis()){
                    calendar.setTimeInMillis(calendar.getTimeInMillis()+24*60*60*1000);
                }
                AlarmData ad=(new AlarmData(calendar.getTimeInMillis()));
                adapter.add(ad);
                alarmManager.set(AlarmManager.RTC_WAKEUP,
                        ad.getTime(),
                        PendingIntent.getBroadcast(getContext(),
                                ad.getId(),
                                new Intent(getContext(),AlarmReceiver.class),0));
                saveAlarmList();
            }
        },c.get(Calendar.HOUR_OF_DAY),c.get(Calendar.MINUTE),true).show();
    }
    private void saveAlarmList(){
        SharedPreferences.Editor editor =getContext().getSharedPreferences(AlarmView.class.getName(),Context.MODE_PRIVATE).edit();

        StringBuffer sb = new StringBuffer();
        for (int i=0;i<adapter.getCount();++i) {
            sb.append(adapter.getItem(i).getTime()).append(",");
        }
        if(sb.length()>1) {
            String content = sb.toString().substring(0, sb.length() - 1);
            editor.putString(KEY_ALARM_LIST, content);
            System.out.println(content);
        }else {
            editor.putString(KEY_ALARM_LIST,null);
        }
            editor.commit();
    }

    private void readSavedAlarmList(){
        SharedPreferences sp=getContext().getSharedPreferences(AlarmView.class.getName(),Context.MODE_PRIVATE);
        String content=sp.getString(KEY_ALARM_LIST,null);
        if (content!=null){
            String[] timeString=content.split(",");
            for (String string:timeString){
                adapter.add(new AlarmData(Long.parseLong(string)));
            }
        }
    }
    private static final String KEY_ALARM_LIST="alarmlist";
    private Button btAddAlarm;
    private ListView lvAlarmList;
    private ArrayAdapter<AlarmData> adapter;
    private AlarmManager alarmManager;
    private static class AlarmData{
        public AlarmData(long time){
            this.time=time;
            date=Calendar.getInstance();
            date.setTimeInMillis(time);

            timeLable=String.format("%d月%d日 %d:%d",
                   date.get(Calendar.MONTH)+1,
                   date.get(Calendar.DAY_OF_MONTH),
                   date.get(Calendar.HOUR_OF_DAY),
                   date.get(Calendar.MINUTE));

        }
        public long getTime(){
            return time;
        }
        public String getTimeLable(){
            return timeLable;
        }
        @Override
        public String toString(){
            return getTimeLable();
        }
        public  int getId() {
            return  (int)(getTime()/1000/60);
        }
        private  String timeLable="";
        private long time=0;
        private Calendar date;
    }
}

计时器页面，TimerView 代码.

// An highlighted block
public class TimerView extends LinearLayout{
    private Button btnStart, btnPause, btnReset;
    private EditText etHour, etMin, etSec;
    private Timer timer = new Timer ( );
    private TimerTask timerTask = null;
    private int allTimerCount = 0;
    private static final int MSG_WHAT_TIME_IS_UP = 1;
    private static final int MSG_WHAT_TIME_TICK = 2;
    
    public TimerView(Context context , @Nullable AttributeSet attrs , int defStyleAttr) {
        super ( context , attrs , defStyleAttr );
    }
    public TimerView(Context context , @Nullable AttributeSet attrs) {
        super ( context , attrs );
    }
    public TimerView(Context context) {
        super ( context );
    }
    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();

        btnPause = (Button) findViewById(R.id.btnPause);
        btnPause.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                stopTimer();
                btnPause.setVisibility(View.GONE);
                btnStart.setVisibility ( View.VISIBLE );
                btnReset.setVisibility(View.VISIBLE);
            }
        });
        btnReset = (Button) findViewById(R.id.btnReset);
        btnReset.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                stopTimer();
                etHour.setText("0");
                etMin.setText("0");
                etSec.setText("0");

                btnReset.setVisibility(View.GONE);
                btnPause.setVisibility(View.GONE);
                btnStart.setVisibility(View.VISIBLE);
            }
        });
        btnStart = (Button) findViewById(R.id.btnStart);
        btnStart.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                startTimer();

                btnStart.setVisibility(View.GONE);
                btnPause.setVisibility(View.VISIBLE);
                btnReset.setVisibility(View.VISIBLE);
            }
        });

        etHour = (EditText) findViewById(R.id.etHour);
        etMin = (EditText) findViewById(R.id.etMin);
        etSec = (EditText) findViewById(R.id.etSec);
        etHour.setText("00");
        etHour.addTextChangedListener(new TextWatcher() {
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (!TextUtils.isEmpty(s)) {
                    int value = Integer.parseInt(s.toString());
                    if (value>59) {
                        etHour.setText("59");
                    }else if (value<0) {
                        etHour.setText("0");
                    }
                }
                checkToEnableBenStart ();
            }
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count,int after) {
            }
            @Override
            public void afterTextChanged(Editable s) {
            }
        });
        etMin.setText("00");
        etMin.addTextChangedListener(new TextWatcher() {

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (!TextUtils.isEmpty(s)) {
                    int value = Integer.parseInt(s.toString());

                    if (value>59) {
                        etMin.setText("59");
                    }else if (value<0) {
                        etMin.setText("0");
                    }
                }
                checkToEnableBenStart ();
            }
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count,int after) {
            }
            @Override
            public void afterTextChanged(Editable s) {
            }
        });
        etSec.setText("00");
        etSec.addTextChangedListener(new TextWatcher() {
            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (!TextUtils.isEmpty(s)) {
                    int value = Integer.parseInt(s.toString());
                    if (value>59) {
                        etSec.setText("59");
                    }else if (value<0) {
                        etSec.setText("0");
                    }
                }
                checkToEnableBenStart ();
            }
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count,int after) {
            }
            @Override
            public void afterTextChanged(Editable s) {
            }
        });

        btnStart.setVisibility(View.VISIBLE);
        btnStart.setEnabled(false);
        btnPause.setVisibility(View.GONE);
        btnReset.setVisibility(View.GONE);
    }
    private void checkToEnableBenStart() {
        btnStart.setEnabled ( (!TextUtils.isEmpty ( etHour.getText ( ) ) && Integer.parseInt ( etHour.getText ( ).toString ( ) ) > 0) ||
                (!TextUtils.isEmpty ( etMin.getText ( ) ) && Integer.parseInt ( etMin.getText ( ).toString ( ) ) > 0) ||
                (!TextUtils.isEmpty ( etSec.getText ( ) ) && Integer.parseInt ( etSec.getText ( ).toString ( ) ) > 0) );
    }
    private void startTimer() {
        allTimerCount = Integer.parseInt ( etHour.getText ( ).toString ( ) ) * 60 * 60 + Integer.parseInt ( etMin.getText ( ).toString ( ) ) * 60 + Integer.parseInt ( etSec.getText ( ).toString ( ) );
        if (timerTask == null) {
            timerTask = new TimerTask ( ) {
                @Override
                public void run() {
                    allTimerCount--;
                    handler.sendEmptyMessage ( MSG_WHAT_TIME_TICK );
                    if (allTimerCount == 0) {
                        handler.sendEmptyMessage ( MSG_WHAT_TIME_IS_UP );
                        stopTimer ( );
                    }
                }
            };
            timer.schedule ( timerTask , 1000 , 1000 );
        }

    }
    
    private void stopTimer() {
        if (timerTask != null) {
            timer.cancel ( );
            timerTask = null;
        }
    }

    private android.os.Handler handler = new android.os.Handler ( ) {
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
                case MSG_WHAT_TIME_TICK:
                    int hour = allTimerCount / 60 / 60;
                    int min = (allTimerCount / 60) % 60;
                    int sec = allTimerCount % 60;
                    etHour.setText ( hour + "" );
                    etMin.setText ( min + "" );
                    etSec.setText ( sec + "" );
                    break;

                case MSG_WHAT_TIME_IS_UP:
                    new AlertDialog.Builder ( getContext ( ) ).setTitle("Timer" )
                            .setMessage ( "时间到" )
                            .setNegativeButton ( "返回" , null )
                            .show ( );
                    btnStart.setVisibility ( View.VISIBLE );
                    btnPause.setVisibility ( View.GONE );
                    btnReset.setVisibility ( View.GONE );
                    break;
                default:
                    break;
            }
        }
    };  
}

秒表页面，StopWatch 代码.

// An highlighted block
public class StopWatch extends LinearLayout {

    private Chronometer myChronometer;
    private Button butStart;
    private Button butStop;
    private Button butResume;
    private Button butReset;

    public StopWatch(Context context , @Nullable AttributeSet attrs) {
        super ( context , attrs );

    }
    @Override
    protected void onFinishInflate() {
        super.onFinishInflate ( );
        
        myChronometer = (Chronometer) super.findViewById ( R.id.myChronometer );
        butStart = (Button) super.findViewById ( R.id.butStart );
        butStop = (Button) super.findViewById ( R.id.butPause );
        butResume=(Button) super.findViewById ( R.id.butResume );
        butReset = (Button) super.findViewById ( R.id.butReset );

        butStart.setVisibility ( View.VISIBLE );
        butStop.setVisibility ( View.GONE);
        butResume.setVisibility ( View.GONE);
        butReset.setVisibility ( View.GONE );
        
        butStart.setOnClickListener ( new OnClickListener ( ) {
            @Override
            public void onClick(View v) {
                myChronometer.setBase ( (long) ((long) (SystemClock.elapsedRealtime ()-
                        (long)Double.parseDouble (myChronometer.getText ().toString ().split ( ":")[0])*60*1000)-
                        (long)Double.parseDouble ( myChronometer.getText ().toString ().split (":" )[1] )*1000) );
                myChronometer.start ();
                butStart.setVisibility ( View.GONE );
                butResume.setVisibility ( View.VISIBLE );
                butStop.setVisibility ( View.VISIBLE);
                butReset.setVisibility ( View.GONE );
            }
        } );

        butStop.setOnClickListener ( new OnClickListener ( ) {
            @Override
            public void onClick(View v) {
                myChronometer.stop ();
                butStop.setVisibility ( View.GONE );
                butResume.setVisibility ( View.GONE);
                butStart.setVisibility ( View.VISIBLE );
                butReset.setVisibility ( View.VISIBLE );
            }
        } );

        butReset.setOnClickListener ( new OnClickListener ( ) {
            @Override
            public void onClick(View v) {
                myChronometer.setBase ( SystemClock.elapsedRealtime ( ) );
                butReset.setVisibility ( View.GONE );
                butResume.setVisibility ( View.GONE );
                butStart.setVisibility ( View.VISIBLE );
                butStop.setVisibility ( View.GONE);
            }
        } );

        butResume.setOnClickListener ( new OnClickListener ( ) {
            @Override
            public void onClick(View v) {
                myChronometer.setFormat ( "%s" );
                myChronometer.setBase ( SystemClock.elapsedRealtime ( ) );
                butStop.setVisibility ( View.VISIBLE );
                butReset.setVisibility ( View.GONE );
                butResume.setVisibility ( View.VISIBLE);
                butStart.setVisibility ( View.GONE );
            }
        } );
    }
}

源码链接

源码下载链接: link.

作者信息

weixingongzhoghao
CodeRain
Authors
CodeRain
CodeRain程序雨
关注
  • 29
    点赞
  • 踩
  • 217
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
Android实战：开发一个简单的闹钟应用
2201_76125261的博客
08-07 832
闹钟应用是一种实用的应用，它能够帮助用户在指定的时间点设置闹钟，并在时间到达时触发提醒。用户可以通过闹钟应用设置多个闹钟，每个闹钟都可以设置不同的提醒时间和提醒音乐。在本篇博客中，我们将开发一个简单的闹钟应用，让您了解闹钟应用的基本实现原理和技术。
Android Studio实现简单的自定义钟表
振华OPPO的博客世界
05-03 1774
在安卓开发中，当系统自带的View已经无法满足项目需求时，就要自定义View。在Android中是没有与钟表有关的View，因此我们制作一个简单的钟表View，这样就可以在其他项目中进行使用。自定义钟表具有表盘，表盘上有12个刻度，有时针、分针、秒针，和家里面的石英表样式相同，用于显示时间会比数码表更加有内涵。总的来说，本次自定义钟表项目可以学习到编程技巧，并且加深对Canvas API的理解。大家可以考虑添加一些定制选项，如不同的表盘样式、颜色或字体，以便用户可以根据自己的喜好来个性化他们的时钟；
Android实现闹钟的所有功能（Android studio）
06-17
闹钟是基于Android studio开发的一款打扰睡觉的app，功能实现闹铃、添加、删除
安卓手机APP开发___设置闹钟
最新发布
红孩儿编程大师
05-29 1437
闹钟（基于 AlarmManager 类）为您提供了一种在应用生命周期之外 执行基于时间的操作的方法。例如，您可以使用闹钟启动长时间运行 的操作，如每天启动一次服务以下载天气预报。
用Android Studio编写简易闹钟（一）
qq_34777575的博客
07-02 1万+
一、闹钟功能的介绍以及界面的展示 该闹钟是根据我们手机闹钟设计的一个简单的闹钟APP，其中包含时钟、闹钟、秒表和计时器功能。用户可以对闹钟添加和删除，可以对秒表计时、暂停和重置，对计时器可以暂停、计时、继续和重置等功能。 下图为闹钟的时钟功能...
android studio调用系统的闹钟
xcj1409385086的博客
02-03 2266
一.首先设计“设置闹钟”的界面 创建activity_set_alarm.xml文件，如下： <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_height="match_parent" android:layout_width="match_parent" an
【Android】开发一个简单时钟应用每天看时间起床
TA远方
01-25 3532
有没有想过，家里闲置不用的旧手机可以当时钟闹钟来用，觉得这个想法可以吧，把闲置手机充分利用起来了呢，接下来给大家讲一下如何实现，功能简单，可以当作编程入门课。
Android Studio闹钟[android源码]
08-05
以上是开发Android Studio闹钟应用的核心技术点，通过理解和实践这些知识点，开发者能够创建出具有闹钟功能的应用，满足用户日常生活中的提醒需求。在实际项目中，还需要关注性能优化、内存管理以及适配不同Android...
Android简易本地音乐播放器源码，基于Android的简易本地音乐播放器源码
01-12
这个"Android简易本地音乐播放器源码"提供了实现这样一个功能的基本框架。以下是对该源码的核心知识点的详细说明： 1. **Android SDK**：首先，你需要对Android SDK有一定的了解，它是开发Android应用的基础。源码...
AlarmNoise:Android的闹钟-开源
05-27
Android警报（基于噪音）。
andriod（app）闹钟源代码
02-06
andriod闹钟源代码,绝对真实的源码，请下载！不要分，但求好评。
Android 之 AlarmManager (闹钟服务)
leyang0910的博客
08-25 1992
本节带来的Android中的AlarmManager(闹钟服务)，听名字我们知道可以通过它开发手机闹钟类的APP， 而在文档中的解释是：在特定的时刻为我们广播一个指定的Intent，简单说就是我们自己定一个时间， 然后当到时间时，AlarmManager会为我们广播一个我们设定好的Intent，比如时间到了，可以指向某个 Activity或者Service！要说的是，此例子只在Android 4.4以下的系统可行，5.0以上并不可行，后续如果有5.0 以上AlarmManager的解决方案，到时再补上！
基于android的个性闹铃的设计与开发（闹铃,日历,计时器,备忘录）
毕业作品网站
11-26 1146
备忘录基本功能要实现事件的添加，还要显示事件列表，能对列表中的事件进行编辑，删除，设置提醒，查看事件详细信息。扩展功能用户可以在搜索页面，通过日期或者关键词的检索以及过滤要能快速找到用户所需要的事件，要能显示搜索结果的事件及信息；(3)事件模块：新增事件，有标题，事件内容可以是文字、图像、视频等，待办类事件可添加闹铃功能，保存事件内容同时保存时间；还可删除事件，编辑事件；（1）首页模块：首页分为备忘录模块、时间显示模块、日历模块、计时器模块，首页的UI设计极大吸引了用户的眼球，增加了用户体验的效果。
Android自定义定时闹钟开发详解
Linuxprobe18的博客
11-30 2238
闹钟的布局很简单，就是一个简单时间设置，所以自己写一个简单的布局按钮之类的也可以了，不过多赘述。增删改查都是对数据库的操作行为，另外使用sqlite去存储时钟的数据，就可以防止数据的丢失，因此可以在时钟的基础上做一个计划提醒之类的，可以把计划里的内容存储进数据库里，还有时间。Toast.makeText(mContext,"23:00~04:59，要好好睡觉的，这是长身体的黄金时间哦~", Toast.LENGTH_LONG).show();// 如果当前时间大于设置的时间，那么就从第二天的设定时间开始。
Android开发一个闹钟
热门推荐
小Tian的博客
08-07 2万+
源码下载地址 GitHub地址https://github.com/jh360twb/Alarmalert-csdn CSDN积分下载https://download.csdn.net/download/qq873044564/11834458 网盘下载地址 链接：https://pan.baidu.com/s/1KUs9Pown2bC8QxvLFGu0Zg 最新2019年10月7...
Android自定义闹钟
xianglongjifei's 博客
03-31 800
1、Android 4.4（API 级别 19）开始，所有重复闹钟都是不精确的，延时2分钟左右。当您设置使用同一待定 Intent 的第二个闹钟时，它会替换原始闹钟。应用将在处于空闲状态时（即用户在一段时间内未使用应用，并且应用没有前台进程时）进入应用待机模式。当应用处于应用待机模式时，闹钟会像设备处于低电耗模式一样被延迟。特点：Android 会同步来自多个应用的重复闹钟，并同时触发它们。2、默认情况下，当设备关机时，所有闹钟都会被取消。所有已设置的闹钟都会推迟，直到设备退出低电耗模式。
推荐开源项目：PleaseWakeUp - 一款智能闹钟应用
gitblog_00060的博客
04-21 349
推荐开源项目：PleaseWakeUp - 一款智能闹钟应用 项目地址:https://gitcode.com/ljian/PleaseWakeUp 项目简介 PleaseWakeUp 是一个创新的闹钟应用，它不仅仅是一个普通的时间提醒工具，更是一款结合了AI技术和生活趣味性的智能闹钟。这款项目的独特之处在于其定制化的唤醒方式和互动体验，旨在让用户在早晨以更加愉快和有效的方式开始新的一天。 技术分...
android studio多功能闹钟
06-28
Android Studio多功能闹钟是一款基于Android Studio开发的应用程序，它具有多种功能，包括闹钟、计时器、倒计时、世界时钟等。用户可以根据自己的需求设置不同的闹钟，比如每天早上7点起床、每周五晚上8点提醒看电影...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodeRain程序雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值