version:1.0.0

update:更换包名
bugfixes:

app/src/main/java/com/xxpatx/os/alarm/AlarmAdapter.java

@@ -0,0 +1,263 @@
+package com.xxpatx.os.alarm;
+
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.media.AudioAttributes;
+import android.media.MediaPlayer;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.constraintlayout.widget.ConstraintLayout;
+import androidx.fragment.app.FragmentActivity;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners;
+import com.bumptech.glide.request.RequestOptions;
+import com.xxpatx.os.R;
+import com.xxpatx.os.activity.alarmclock.edit.AlarmClockEditActivity;
+import com.xxpatx.os.utils.FFmpegUtils;
+import com.xxpatx.os.utils.ScreenUtils;
+import com.xxpatx.os.utils.Utils;
+import com.xxpatx.os.view.JzvdStdRound;
+
+import java.io.File;
+import java.io.IOException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import io.reactivex.rxjava3.core.Observer;
+import io.reactivex.rxjava3.disposables.Disposable;
+
+public class AlarmAdapter extends RecyclerView.Adapter<AlarmAdapter.holder> {
+
+    private FragmentActivity mContext;
+    private List<AlarmClockData> mAlarmClockData;
+    private OnLongClickListener mOnLongClickListener;
+
+    public void setAlarmClockData(List<AlarmClockData> alarmClockData) {
+        this.mAlarmClockData = alarmClockData;
+        notifyDataSetChanged();
+    }
+
+    public void setOnLongClickListener(OnLongClickListener onLongClickListener) {
+        this.mOnLongClickListener = onLongClickListener;
+    }
+
+    public interface OnLongClickListener {
+        void onLongClick(AlarmClockData alarmClockData);
+    }
+
+    @NonNull
+    @Override
+    public holder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+        mContext = (FragmentActivity) parent.getContext();
+        return new AlarmAdapter.holder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_alarm_clock, parent, false));
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull holder holder, int position) {
+        AlarmClockData alarmClockData = mAlarmClockData.get(position);
+        switch (alarmClockData.getType()) {
+            case AlarmUtils.ONCE:
+                try {
+                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
+                    Date date = sdf.parse(alarmClockData.getTime());
+                    SimpleDateFormat hours = new SimpleDateFormat("HH:mm");
+                    String time = hours.format(date);
+                    holder.tv_time.setText(time);
+                } catch (ParseException e) {
+                    e.printStackTrace();
+                }
+                holder.tv_remind_type.setText("一次");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_once);
+                break;
+            case AlarmUtils.LOOP:
+                holder.tv_time.setText(alarmClockData.getTime());
+                holder.tv_remind_type.setText("每天");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_loop);
+                break;
+            case AlarmUtils.WORKING_DAY:
+                holder.tv_time.setText(alarmClockData.getTime());
+                holder.tv_remind_type.setText("周一至周五");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_work);
+                break;
+            case AlarmUtils.OFF_DAY:
+                holder.tv_time.setText(alarmClockData.getTime());
+                holder.tv_remind_type.setText("周六至周日");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_offday);
+                break;
+            default:
+        }
+        String title = alarmClockData.getTitle();
+        if (TextUtils.isEmpty(title)) {
+            holder.tv_title.setText("无标题");
+        } else {
+            holder.tv_title.setText(title);
+        }
+        String voice = alarmClockData.getVoice();
+        if (TextUtils.isEmpty(voice)) {
+            holder.cl_voice.setVisibility(View.GONE);
+        } else {
+            holder.cl_voice.setVisibility(View.VISIBLE);
+            MediaPlayer mMediaPlayer = new MediaPlayer();
+            mMediaPlayer.setAudioAttributes(
+                    new AudioAttributes.Builder()
+                            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                            .build()
+            );
+            mMediaPlayer.setOnCompletionListener(mp -> Log.e("setOnCompletionListener", "onCompletion: "));
+            mMediaPlayer.setOnPreparedListener(mp -> Log.e("setOnPreparedListener", "onPrepared: "));
+            mMediaPlayer.setOnErrorListener((mp, what, extra) -> false);
+            //设置音频文件到MediaPlayer对象中
+            try {
+                mMediaPlayer.setDataSource(voice);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            //让MediaPlayer对象准备，用这个方法防止加载时耗时导致anr
+            mMediaPlayer.prepareAsync();
+            FFmpegUtils.getDurationInMilliseconds(voice, new Observer<Integer>() {
+                @Override
+                public void onSubscribe(@NonNull Disposable d) {
+
+                }
+
+                @Override
+                public void onNext(@NonNull Integer integer) {
+                    holder.tv_voice.setText(integer + "秒");
+                }
+
+                @Override
+                public void onError(@NonNull Throwable e) {
+
+                }
+
+                @Override
+                public void onComplete() {
+
+                }
+            });
+            holder.cl_voice.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    mMediaPlayer.start();
+                }
+            });
+        }
+        String fileUrl = alarmClockData.getFile();
+        if (TextUtils.isEmpty(fileUrl)) {
+            holder.cl_vp.setVisibility(View.GONE);
+        } else {
+            holder.cl_vp.setVisibility(View.VISIBLE);
+            if (isImgUrl(fileUrl)) {
+                holder.imageView.setVisibility(View.VISIBLE);
+                holder.jz_video.setVisibility(View.GONE);
+                if (!mContext.isDestroyed()) {
+                    RequestOptions options = new RequestOptions().transform(new RoundedCorners(ScreenUtils.dip2px(mContext, 16F)));
+                    Glide.with(mContext).load(fileUrl).apply(options).into(holder.imageView);
+                }
+            } else {
+                holder.imageView.setVisibility(View.GONE);
+                holder.jz_video.setVisibility(View.VISIBLE);
+                String fileName = Utils.getFileNamefromURL(fileUrl);
+                File file = new File(Utils.getDownLoadPath(mContext) + fileName);
+                String path;
+                if (file.exists() && !file.isDirectory()) {
+                    path = file.getAbsolutePath();
+                } else {
+                    path = fileUrl;
+                }
+                holder.jz_video.setUp(path, "");
+                holder.jz_video.startButton.setImageDrawable(mContext.getDrawable(R.drawable.play));
+                FFmpegUtils.loadVideoScreenshot(path, new Observer<Bitmap>() {
+                    @Override
+                    public void onSubscribe(@NonNull Disposable d) {
+
+                    }
+
+                    @Override
+                    public void onNext(@NonNull Bitmap bitmap) {
+                        if (!mContext.isDestroyed()) {
+                            RequestOptions options = new RequestOptions().transform(new RoundedCorners(ScreenUtils.dip2px(mContext, 16F)));
+                            Glide.with(mContext).load(bitmap).apply(options).into(holder.jz_video.posterImageView);
+//                            Glide.with(mContext).load(bitmap).into(holder.imageView);
+                        }
+                        holder.jz_video.startButton.setImageDrawable(mContext.getDrawable(R.drawable.play));
+                    }
+
+                    @Override
+                    public void onError(@NonNull Throwable e) {
+
+                    }
+
+                    @Override
+                    public void onComplete() {
+
+                    }
+                });
+
+            }
+        }
+        holder.root.setOnLongClickListener(new View.OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View view) {
+                mOnLongClickListener.onLongClick(alarmClockData);
+                return false;
+            }
+        });
+        holder.root.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                Intent intent = new Intent(mContext, AlarmClockEditActivity.class);
+                intent.putExtra("id", alarmClockData.getId());
+                mContext.startActivity(intent);
+            }
+        });
+
+    }
+
+    private Pattern mCompile = Pattern.compile(".*?(gif|jpeg|png|jpg|bmp|webp)");
+
+    private boolean isImgUrl(String url) {
+        if (TextUtils.isEmpty(url) || url.trim().length() == 0) {
+            return false;
+        }
+        return mCompile.matcher(url).matches();
+    }
+
+    @Override
+    public int getItemCount() {
+        return mAlarmClockData == null ? 0 : mAlarmClockData.size();
+    }
+
+    class holder extends RecyclerView.ViewHolder {
+        TextView tv_time, tv_remind_type, tv_title, tv_voice;
+        ConstraintLayout cl_voice, cl_vp, root;
+        JzvdStdRound jz_video;
+        ImageView imageView;
+
+        public holder(@NonNull View itemView) {
+            super(itemView);
+            tv_time = itemView.findViewById(R.id.tv_time);
+            tv_remind_type = itemView.findViewById(R.id.tv_remind_type);
+            tv_title = itemView.findViewById(R.id.tv_title);
+            tv_voice = itemView.findViewById(R.id.tv_voice);
+            cl_voice = itemView.findViewById(R.id.cl_voice);
+            cl_vp = itemView.findViewById(R.id.cl_vp);
+            root = itemView.findViewById(R.id.root);
+            jz_video = itemView.findViewById(R.id.jz_video);
+            imageView = itemView.findViewById(R.id.imageView);
+        }
+    }
+}
+

app/src/main/java/com/xxpatx/os/alarm/AlarmClockData.java

@@ -0,0 +1,212 @@
+package com.xxpatx.os.alarm;
+
+import android.text.TextUtils;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonParser;
+import com.google.gson.annotations.SerializedName;
+
+import java.io.Serializable;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Objects;
+
+public class AlarmClockData implements Serializable {
+    private static final long serialVersionUID = -5856502480745183157L;
+
+    int id;
+    int type;//类型 1一次 2循环 3周一到周五 4 周六周日
+    String time;//"2021-11-15 18:33:23",//时间格式化字符串，循环类型是18:33:23
+    String title;//标题
+    String voice;//语音文件地址
+    String voice_md5;
+    String file;//图片或视频文件地址
+    String file_md5;
+    int remind_type;
+    int is_onoff;//0关闭 1开启
+    @SerializedName("class")
+    int clazz;
+
+    boolean finished = false;
+    boolean is_local = false;
+    boolean edited = false;
+    boolean deleted = false;
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    public void setType(int type) {
+        this.type = type;
+    }
+
+    public String getTime() {
+        return time;
+    }
+
+    public void setTime(String time) {
+        this.time = time;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public String getVoice() {
+        return voice;
+    }
+
+    public void setVoice(String voice) {
+        this.voice = voice;
+    }
+
+    public String getVoice_md5() {
+        return voice_md5;
+    }
+
+    public void setVoice_md5(String voice_md5) {
+        this.voice_md5 = voice_md5;
+    }
+
+    public String getFile() {
+        return file;
+    }
+
+    public void setFile(String file) {
+        this.file = file;
+    }
+
+    public String getFile_md5() {
+        return file_md5;
+    }
+
+    public void setFile_md5(String file_md5) {
+        this.file_md5 = file_md5;
+    }
+
+    public boolean isFinished() {
+        return finished;
+    }
+
+    public void setFinished(boolean finished) {
+        this.finished = finished;
+    }
+
+    public int getRemind_type() {
+        return remind_type;
+    }
+
+    public void setRemind_type(int remind_type) {
+        this.remind_type = remind_type;
+    }
+
+    public int getIs_onoff() {
+        return is_onoff;
+    }
+
+    public void setIs_onoff(int is_onoff) {
+        this.is_onoff = is_onoff;
+    }
+
+    public int getClazz() {
+        return clazz;
+    }
+
+    public void setClazz(int clazz) {
+        this.clazz = clazz;
+    }
+
+    public boolean isIs_local() {
+        return is_local;
+    }
+
+    public void setIs_local(boolean is_local) {
+        this.is_local = is_local;
+    }
+
+    public boolean isEdited() {
+        return edited;
+    }
+
+    public void setEdited(boolean edited) {
+        this.edited = edited;
+    }
+
+    public boolean isDeleted() {
+        return deleted;
+    }
+
+    public void setDeleted(boolean deleted) {
+        this.deleted = deleted;
+    }
+
+    public long getTimeStamp() {
+        if (TextUtils.isEmpty(time)) {
+            return 0L;
+        }
+        if (time.length() == 5) {
+            String[] timeSplit = time.split(":");
+            int hour = Integer.parseInt(timeSplit[0]);
+            int minute = Integer.parseInt(timeSplit[1]);
+            Calendar c = Calendar.getInstance();
+            c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH),
+                    c.get(Calendar.DAY_OF_MONTH), hour, minute, 0);
+            long mTimeInfo = c.getTimeInMillis();
+            Log.e("AlarmClockData", "getTimeStamp: " + mTimeInfo);
+            long actualTime = mTimeInfo > System.currentTimeMillis() ? mTimeInfo : mTimeInfo + AlarmUtils.ONE_DAY_TIME;
+            return actualTime;
+        } else {
+            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            try {
+                Date date = simpleDateFormat.parse(time);
+                long timestamp = date.getTime();
+                return timestamp;
+            } catch (ParseException e) {
+                return System.currentTimeMillis();
+            }
+        }
+    }
+
+
+    @NonNull
+    @Override
+    public String toString() {
+        return JsonParser.parseString(new Gson().toJson(this)).getAsJsonObject().toString();
+    }
+
+    @Override
+    public boolean equals(@Nullable Object obj) {
+        if (obj == null) return false;
+        if (!(obj instanceof AlarmClockData)) return false;
+        if (id != ((AlarmClockData) obj).id) return false;
+        if (type != ((AlarmClockData) obj).type) return false;
+        if (!Objects.equals(time, ((AlarmClockData) obj).time)) return false;
+        if (!Objects.equals(title, ((AlarmClockData) obj).title)) return false;
+        if (!Objects.equals(voice, ((AlarmClockData) obj).voice)) return false;
+        if (!Objects.equals(voice_md5, ((AlarmClockData) obj).voice_md5)) return false;
+        if (!Objects.equals(file, ((AlarmClockData) obj).file)) return false;
+        if (!Objects.equals(file_md5, ((AlarmClockData) obj).file_md5)) return false;
+        if (remind_type != ((AlarmClockData) obj).remind_type) return false;
+        if (is_onoff != ((AlarmClockData) obj).is_onoff) return false;
+
+        return true;
+    }
+}

app/src/main/java/com/xxpatx/os/alarm/AlarmOpenHelper.java

@@ -0,0 +1,75 @@
+package com.xxpatx.os.alarm;
+
+import android.content.Context;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+
+public class AlarmOpenHelper extends SQLiteOpenHelper {
+
+    public static final int DATABASE_VERSION = 2;
+    public static final String DATABASE_NAME = "AlarmDatabase.db";
+    //    public static final String DATABASE_FILE_NAME = Environment.getExternalStorageDirectory().getPath() + File.separator + DATABASE_NAME;
+    public static final String DATABASE_FILE_NAME = DATABASE_NAME;
+
+    public static final String TABLE_ALARM = " AlarmTable";
+
+    public static final String KEY_ID = "id";
+    public static final String KEY_TYPE = "type";
+    public static final String KEY_TIME = "time";
+    public static final String KEY_TITLE = "title";
+    public static final String KEY_VOICE = "voice";
+    public static final String KEY_VOICE_MD5 = "voice_md5";
+    public static final String KEY_FILE = "file";
+    public static final String KEY_FILE_MD5 = "file_md5";
+    public static final String KEY_REMIND_TYPE = "remind_type";
+    public static final String KEY_IS_ONOFF = "is_onoff";
+
+    public static final String KEY_FINISHED = "finished";
+    public static final String KEY_IS_LOCAL = "is_local";
+    public static final String KEY_EDITED = "edited";
+    public static final String KEY_DELETED = "deleted";
+
+
+    String CREATE_ALARM_TABLE = "CREATE TABLE IF NOT EXISTS" + TABLE_ALARM +
+            "("
+            + KEY_ID + " INTEGER PRIMARY KEY,"
+            + KEY_TYPE + " INTEGER,"
+            + KEY_TIME + " TEXT,"
+            + KEY_TITLE + " TEXT,"
+            + KEY_VOICE + " TEXT,"
+            + KEY_VOICE_MD5 + " TEXT,"
+            + KEY_FILE + " TEXT,"
+            + KEY_FILE_MD5 + " TEXT,"
+            + KEY_REMIND_TYPE + " INTEGER,"
+            + KEY_IS_ONOFF + " INTEGER,"
+
+            + KEY_FINISHED + " BOOLEAN DEFAULT 0,"
+            + KEY_IS_LOCAL + " BOOLEAN DEFAULT 0,"
+            + KEY_EDITED + " BOOLEAN DEFAULT 0,"
+            + KEY_DELETED + " BOOLEAN DEFAULT 0"
+            + ")";
+
+    public AlarmOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory, int version) {
+        super(context, name, factory, version);
+    }
+
+    @Override
+    public void onCreate(SQLiteDatabase db) {
+        db.execSQL(CREATE_ALARM_TABLE);
+    }
+
+    @Override
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        switch (oldVersion + 1) {
+            case 1:
+                db.execSQL(CREATE_ALARM_TABLE);  // 执行修改表，添加字段的逻辑。
+            case 2:
+                String sql = "ALTER TABLE " + TABLE_ALARM + " ADD COLUMN " + KEY_EDITED + "  BOOLEAN DEFAULT 0";
+                db.execSQL(sql);
+                String sql2 = "ALTER TABLE " + TABLE_ALARM + " ADD COLUMN " + KEY_DELETED + "  BOOLEAN DEFAULT 0";
+                db.execSQL(sql2);
+                String sql3 = "ALTER TABLE " + TABLE_ALARM + " ADD COLUMN " + KEY_FILE_MD5 + "  TEXT";
+                db.execSQL(sql3);
+        }
+    }
+}

app/src/main/java/com/xxpatx/os/alarm/AlarmService.java

@@ -0,0 +1,16 @@
+package com.xxpatx.os.alarm;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+
+public class AlarmService extends Service {
+    public AlarmService() {
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+}

app/src/main/java/com/xxpatx/os/alarm/AlarmUtils.java

@@ -0,0 +1,848 @@
+package com.xxpatx.os.alarm;
+
+import android.annotation.SuppressLint;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.arialyy.aria.core.Aria;
+import com.blankj.utilcode.util.FileUtils;
+import com.xxpatx.os.service.main.MainService;
+import com.xxpatx.os.utils.FileUtil;
+import com.xxpatx.os.utils.Utils;
+
+import java.io.File;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+
+public class AlarmUtils {
+    private static final String TAG = AlarmUtils.class.getSimpleName();
+
+    @SuppressLint("StaticFieldLeak")
+    private static AlarmUtils sInstance;
+    private Context mContext;
+    private AlarmManager mAlarmManager;
+    private SQLiteDatabase mDatabase;
+    private AlarmOpenHelper mAlarmOpenHelper;
+    private HashSet<PendingIntent> pendingIntents;
+
+    public static final int ONE_DAY_TIME = 1000 * 60 * 60 * 24;
+
+    /*一次性*/
+    public static final int ONCE = 1;
+    /*每天*/
+    public static final int LOOP = 2;
+    /*周一到周五*/
+    public static final int WORKING_DAY = 3;
+    /*休息日*/
+    public static final int OFF_DAY = 4;
+
+    private AlarmUtils(Context context) {
+        this.mContext = context;
+//        this.mAlarmOpenHelper = new AlarmOpenHelper(context, AlarmOpenHelper.DATABASE_NAME, null, AlarmOpenHelper.DATABASE_VERSION);
+        this.mAlarmOpenHelper = new AlarmOpenHelper(context,
+                context.getExternalCacheDir() + File.separator + AlarmOpenHelper.DATABASE_FILE_NAME,
+                null, AlarmOpenHelper.DATABASE_VERSION);
+        this.mDatabase = mAlarmOpenHelper.getWritableDatabase();
+        this.mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+    }
+
+    public static void init(Context context) {
+        if (context == null) {
+            throw new RuntimeException("context is NULL");
+        }
+        if (sInstance == null) {
+            sInstance = new AlarmUtils(context);
+        }
+    }
+
+    public static AlarmUtils getInstance() {
+        if (sInstance == null) {
+            throw new IllegalStateException("You must be init AlarmUtils first");
+        }
+        return sInstance;
+    }
+
+    private void openDatabase() {
+//        if (mDatabase == null || !mDatabase.isOpen()) {
+//            mDatabase = mAlarmOpenHelper.getWritableDatabase();
+//        }
+    }
+
+    private ContentValues getValuesFromAlarmClock(AlarmClockData alarmClockData) {
+        ContentValues values = new ContentValues();
+        values.put(AlarmOpenHelper.KEY_ID, alarmClockData.getId());
+        values.put(AlarmOpenHelper.KEY_TYPE, alarmClockData.getType());
+        values.put(AlarmOpenHelper.KEY_TIME, alarmClockData.getTime());
+        values.put(AlarmOpenHelper.KEY_TITLE, alarmClockData.getTitle());
+        values.put(AlarmOpenHelper.KEY_VOICE, alarmClockData.getVoice());
+        values.put(AlarmOpenHelper.KEY_VOICE_MD5, alarmClockData.getVoice_md5());
+        values.put(AlarmOpenHelper.KEY_FILE, alarmClockData.getFile());
+        values.put(AlarmOpenHelper.KEY_FILE_MD5, alarmClockData.getFile_md5());
+        values.put(AlarmOpenHelper.KEY_REMIND_TYPE, alarmClockData.getRemind_type());
+        values.put(AlarmOpenHelper.KEY_IS_ONOFF, alarmClockData.getIs_onoff());
+
+        values.put(AlarmOpenHelper.KEY_FINISHED, alarmClockData.isFinished());
+        values.put(AlarmOpenHelper.KEY_IS_LOCAL, alarmClockData.isIs_local());
+        values.put(AlarmOpenHelper.KEY_EDITED, alarmClockData.isEdited());
+        values.put(AlarmOpenHelper.KEY_DELETED, alarmClockData.isDeleted());
+        return values;
+    }
+
+    /**
+     * 增加数据
+     *
+     * @param alarmClockData
+     * @return
+     */
+    public boolean addAlarmClock(AlarmClockData alarmClockData) {
+        openDatabase();
+        ContentValues values = getValuesFromAlarmClock(alarmClockData);
+        long id = 0;
+        mDatabase.beginTransaction();
+        try {
+            id = mDatabase.insertWithOnConflict(AlarmOpenHelper.TABLE_ALARM, null, values, SQLiteDatabase.CONFLICT_REPLACE);
+            mDatabase.setTransactionSuccessful();
+        } catch (Exception e) {
+            Log.e(TAG, "addAlarmClock: " + e.getMessage());
+        } finally {
+            mDatabase.endTransaction();
+        }
+        setAlarm(alarmClockData);
+        return id > 0;
+    }
+
+
+    /**
+     * 更新数据
+     *
+     * @param alarmClockData
+     * @return
+     */
+    public boolean updateAlarmClock(AlarmClockData alarmClockData) {
+        openDatabase();
+        AlarmClockData old = getDatabaseSingleAlarm(alarmClockData);
+        if (old != null) {
+            PendingIntent pendingIntent = getPendingIntent(old);
+            if (pendingIntent != null) {
+                mAlarmManager.cancel(pendingIntent);
+            }
+        }
+        ContentValues values = getValuesFromAlarmClock(alarmClockData);
+        long id = 0;
+        mDatabase.beginTransaction();
+        try {
+            id = mDatabase.insertWithOnConflict(AlarmOpenHelper.TABLE_ALARM, null, values, SQLiteDatabase.CONFLICT_REPLACE);
+            mDatabase.setTransactionSuccessful();
+        } catch (Exception e) {
+            Log.e(TAG, "updateAlarmClock: " + e.getMessage());
+        } finally {
+            mDatabase.endTransaction();
+        }
+        setAlarm(alarmClockData);
+        return id > 0;
+    }
+
+    public boolean updateAlarmClock(AlarmClockData alarmClockData, int newId) {
+        openDatabase();
+        int oldId = alarmClockData.getId();
+        AlarmClockData old = getDatabaseSingleAlarm(alarmClockData);
+        if (old != null) {
+//            deleteAlarmClock(oldId);
+            PendingIntent pendingIntent = getPendingIntent(old);
+            if (pendingIntent != null) {
+                mAlarmManager.cancel(pendingIntent);
+            }
+        }
+        alarmClockData.setId(newId);
+        ContentValues values = getValuesFromAlarmClock(alarmClockData);
+        long id = 0;
+        mDatabase.beginTransaction();
+        try {
+            id = mDatabase.update(AlarmOpenHelper.TABLE_ALARM, values, "id=" + oldId, null);
+            mDatabase.setTransactionSuccessful();
+        } catch (Exception e) {
+            Log.e(TAG, "updateAlarmClock: " + e.getMessage());
+        } finally {
+            mDatabase.endTransaction();
+        }
+        setAlarm(alarmClockData);
+        return id > 0;
+    }
+
+    /**
+     * 批量插入数据
+     *
+     * @param list
+     */
+    public void insertAlarmClockList(List<AlarmClockData> list) {
+        openDatabase();
+        List<ContentValues> contentValuesList = new ArrayList<>();
+        for (AlarmClockData alarmClockData : list) {
+            ContentValues values = getValuesFromAlarmClock(alarmClockData);
+            contentValuesList.add(values);
+        }
+        mDatabase.beginTransaction();
+        try {
+            for (ContentValues v : contentValuesList) {
+                mDatabase.insertWithOnConflict(AlarmOpenHelper.TABLE_ALARM, null, v, SQLiteDatabase.CONFLICT_REPLACE);
+            }
+            mDatabase.setTransactionSuccessful();
+        } catch (Exception e) {
+            Log.e(TAG, "insertListValues: " + e.getMessage());
+        } finally {
+            mDatabase.endTransaction();
+        }
+    }
+
+    /**
+     * 删除数据
+     *
+     * @param alarmClockData
+     * @return
+     */
+    public boolean deleteAlarmClock(AlarmClockData alarmClockData) {
+        if (alarmClockData == null) {
+            return true;
+        }
+        PendingIntent pendingIntent = getPendingIntent(alarmClockData);
+        if (pendingIntent != null) {
+            mAlarmManager.cancel(pendingIntent);
+        }
+        return deleteAlarmClock(alarmClockData.getId());
+    }
+
+    public boolean deleteAlarmClock(int RowID) {
+        openDatabase();
+        long id = 0;
+        mDatabase.beginTransaction();
+        try {
+            id = mDatabase.delete(AlarmOpenHelper.TABLE_ALARM, " id =" + RowID, null);
+            mDatabase.setTransactionSuccessful();
+        } catch (Exception e) {
+            Log.e(TAG, "deleteAlarmClock: " + e.getMessage());
+        } finally {
+            mDatabase.endTransaction();
+        }
+        return id > 0;
+    }
+
+    /**
+     * 删除所有闹钟
+     */
+    public void deleteAllAlarmClock() {
+        HashSet<PendingIntent> pendingIntents = getOldPendingIntentsSet();
+        Iterator<PendingIntent> pendingIntentIterator = pendingIntents.iterator();
+        while (pendingIntentIterator.hasNext()) {
+            PendingIntent pendingIntent = pendingIntentIterator.next();
+            mAlarmManager.cancel(pendingIntent);
+            pendingIntentIterator.remove();
+        }
+        List<AlarmClockData> alarmClockData = getDatabaseAlarms();
+        for (AlarmClockData data : alarmClockData) {
+            deleteAlarmClock(data.getId());
+        }
+    }
+
+    /**
+     * 获取所有Alarm
+     *
+     * @return
+     */
+    public List<AlarmClockData> getDatabaseAlarms() {
+        openDatabase();
+        List<AlarmClockData> list = new ArrayList<>();
+        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM;
+        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
+        if (cursor.moveToFirst()) {
+            do {
+                AlarmClockData alarmClockData = new AlarmClockData();
+                alarmClockData.setId(Integer.parseInt(cursor.getString(0)));
+                alarmClockData.setType(cursor.getInt(1));
+                alarmClockData.setTime(cursor.getString(2));
+                alarmClockData.setTitle(cursor.getString(3));
+                alarmClockData.setVoice(cursor.getString(4));
+                alarmClockData.setVoice_md5(cursor.getString(5));
+                alarmClockData.setFile(cursor.getString(6));
+                alarmClockData.setFile_md5(cursor.getString(7));
+                alarmClockData.setRemind_type(cursor.getInt(8));
+                alarmClockData.setIs_onoff(cursor.getInt(9));
+                alarmClockData.setFinished(cursor.getInt(10) == 1);
+                alarmClockData.setIs_local(cursor.getInt(11) == 1);
+                alarmClockData.setEdited(cursor.getInt(12) == 1);
+                alarmClockData.setDeleted(cursor.getInt(13) == 1);
+                list.add(alarmClockData);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        return list;
+    }
+
+    /**
+     * @return 获取单个闹钟
+     */
+    public AlarmClockData getDatabaseSingleAlarm(AlarmClockData data) {
+        openDatabase();
+        List<AlarmClockData> list = new ArrayList<>();
+        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM + " where id =" + data.getId();
+        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
+        if (cursor.moveToFirst()) {
+            do {
+                AlarmClockData alarmClockData = new AlarmClockData();
+                alarmClockData.setId(Integer.parseInt(cursor.getString(0)));
+                alarmClockData.setType(cursor.getInt(1));
+                alarmClockData.setTime(cursor.getString(2));
+                alarmClockData.setTitle(cursor.getString(3));
+                alarmClockData.setVoice(cursor.getString(4));
+                alarmClockData.setVoice_md5(cursor.getString(5));
+                alarmClockData.setFile(cursor.getString(6));
+                alarmClockData.setFile_md5(cursor.getString(7));
+                alarmClockData.setRemind_type(cursor.getInt(8));
+                alarmClockData.setIs_onoff(cursor.getInt(9));
+                alarmClockData.setFinished(cursor.getInt(10) == 1);
+                alarmClockData.setIs_local(cursor.getInt(11) == 1);
+                alarmClockData.setEdited(cursor.getInt(12) == 1);
+                alarmClockData.setDeleted(cursor.getInt(13) == 1);
+                list.add(alarmClockData);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        return list.size() == 0 ? null : list.get(0);
+    }
+
+    public AlarmClockData getDatabaseSingleAlarm(int id) {
+        openDatabase();
+        List<AlarmClockData> list = new ArrayList<>();
+        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM + " where id =" + id;
+        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
+        if (cursor.moveToFirst()) {
+            do {
+                AlarmClockData alarmClockData = new AlarmClockData();
+                alarmClockData.setId(Integer.parseInt(cursor.getString(0)));
+                alarmClockData.setType(cursor.getInt(1));
+                alarmClockData.setTime(cursor.getString(2));
+                alarmClockData.setTitle(cursor.getString(3));
+                alarmClockData.setVoice(cursor.getString(4));
+                alarmClockData.setVoice_md5(cursor.getString(5));
+                alarmClockData.setFile(cursor.getString(6));
+                alarmClockData.setFile_md5(cursor.getString(7));
+                alarmClockData.setRemind_type(cursor.getInt(8));
+                alarmClockData.setIs_onoff(cursor.getInt(9));
+                alarmClockData.setFinished(cursor.getInt(10) == 1);
+                alarmClockData.setIs_local(cursor.getInt(11) == 1);
+                alarmClockData.setEdited(cursor.getInt(12) == 1);
+                alarmClockData.setDeleted(cursor.getInt(13) == 1);
+                list.add(alarmClockData);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        return list.size() == 0 ? null : list.get(0);
+    }
+
+    public List<AlarmClockData> getDeletedAlarm() {
+        openDatabase();
+        List<AlarmClockData> list = new ArrayList<>();
+        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM + " where deleted = 1";
+        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
+        if (cursor.moveToFirst()) {
+            do {
+                AlarmClockData alarmClockData = new AlarmClockData();
+                alarmClockData.setId(Integer.parseInt(cursor.getString(0)));
+                alarmClockData.setType(cursor.getInt(1));
+                alarmClockData.setTime(cursor.getString(2));
+                alarmClockData.setTitle(cursor.getString(3));
+                alarmClockData.setVoice(cursor.getString(4));
+                alarmClockData.setVoice_md5(cursor.getString(5));
+                alarmClockData.setFile(cursor.getString(6));
+                alarmClockData.setFile_md5(cursor.getString(7));
+                alarmClockData.setRemind_type(cursor.getInt(8));
+                alarmClockData.setIs_onoff(cursor.getInt(9));
+                alarmClockData.setFinished(cursor.getInt(10) == 1);
+                alarmClockData.setIs_local(cursor.getInt(11) == 1);
+                alarmClockData.setEdited(cursor.getInt(12) == 1);
+                alarmClockData.setDeleted(cursor.getInt(13) == 1);
+                list.add(alarmClockData);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        return list;
+    }
+
+    public List<AlarmClockData> getLocalAddAlarm() {
+        openDatabase();
+        List<AlarmClockData> list = new ArrayList<>();
+        String selectQuery = "SELECT * FROM " + AlarmOpenHelper.TABLE_ALARM + " where is_local = 1";
+        Cursor cursor = mDatabase.rawQuery(selectQuery, null);
+        if (cursor.moveToFirst()) {
+            do {
+                AlarmClockData alarmClockData = new AlarmClockData();
+                alarmClockData.setId(Integer.parseInt(cursor.getString(0)));
+                alarmClockData.setType(cursor.getInt(1));
+                alarmClockData.setTime(cursor.getString(2));
+                alarmClockData.setTitle(cursor.getString(3));
+                alarmClockData.setVoice(cursor.getString(4));
+                alarmClockData.setVoice_md5(cursor.getString(5));
+                alarmClockData.setFile(cursor.getString(6));
+                alarmClockData.setFile_md5(cursor.getString(7));
+                alarmClockData.setRemind_type(cursor.getInt(8));
+                alarmClockData.setIs_onoff(cursor.getInt(9));
+                alarmClockData.setFinished(cursor.getInt(10) == 1);
+                alarmClockData.setIs_local(cursor.getInt(11) == 1);
+                alarmClockData.setEdited(cursor.getInt(12) == 1);
+                alarmClockData.setDeleted(cursor.getInt(13) == 1);
+                list.add(alarmClockData);
+            } while (cursor.moveToNext());
+        }
+        cursor.close();
+        return list;
+    }
+
+
+    /**
+     * 设置闹钟列表
+     *
+     * @param data
+     */
+    public void setAlarmClockData(List<AlarmClockData> data) {
+        if (pendingIntents == null) {
+            pendingIntents = getOldPendingIntentsSet();
+        }
+        Iterator<PendingIntent> pendingIntentIterator = pendingIntents.iterator();
+        while (pendingIntentIterator.hasNext()) {
+            PendingIntent pendingIntent = pendingIntentIterator.next();
+            mAlarmManager.cancel(pendingIntent);
+            pendingIntentIterator.remove();
+        }
+        List<AlarmClockData> newData = mergeData(data);
+        for (AlarmClockData clockData : newData) {
+            setAlarm(clockData);
+            checkResource(clockData.getFile());
+        }
+        insertAlarmClockList(newData);
+    }
+
+    /**
+     * @param url 下载资源
+     */
+    private void checkResource(String url) {
+        if (TextUtils.isEmpty(url)) {
+            return;
+        }
+        String fileName = url.substring(url.lastIndexOf("/") + 1, url.length());
+        String realPath = Utils.getDownLoadPath(mContext) + fileName;
+        File file = new File(realPath);
+        if (!file.exists()) {
+            Aria.download(this)
+                    .load(url)     //读取下载地址
+                    .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
+                    .create();   //启动下载}
+        }
+    }
+
+    /**
+     * 合并闹钟列表，删除不存在闹钟
+     *
+     * @param newAlarmClockDataList
+     * @return 新增的闹钟
+     */
+    private List<AlarmClockData> mergeData(List<AlarmClockData> newAlarmClockDataList) {
+        HashMap<Integer, AlarmClockData> alarmClockDataMap = new HashMap<>();
+        if (newAlarmClockDataList != null) {
+            for (AlarmClockData alarmClockData : newAlarmClockDataList) {
+                alarmClockDataMap.put(alarmClockData.getId(), alarmClockData);
+            }
+        }
+        HashMap<Integer, AlarmClockData> oldData = getOldDataMap();
+        List<AlarmClockData> deleteData = new ArrayList<>();
+        for (Map.Entry<Integer, AlarmClockData> entry : oldData.entrySet()) {
+            if (alarmClockDataMap.get(entry.getKey()) == null) {
+                deleteData.add(entry.getValue());
+            }
+        }
+        for (AlarmClockData alarmClockData : deleteData) {
+            if (alarmClockData.isIs_local() || alarmClockData.deleted) {
+                Log.e(TAG, "mergeData: skip " + alarmClockData.getId());
+                continue;
+            }
+            deleteAlarmClock(alarmClockData);
+        }
+
+        List<AlarmClockData> newData = new ArrayList<>();
+        if (newAlarmClockDataList == null) {
+            return newData;
+        }
+        for (AlarmClockData alarm : newAlarmClockDataList) {
+            AlarmClockData oldAlarm = oldData.get(alarm.getId());
+            if (oldAlarm == null) {
+                newData.add(alarm);
+            } else {
+                if (oldAlarm.equals(alarm)) {
+                    newData.add(oldAlarm);
+                } else {
+                    newData.add(alarm);
+                }
+            }
+        }
+        return newData;
+    }
+
+    /**
+     * 更新完成状态
+     *
+     * @param alarmClockData
+     * @return
+     */
+    public boolean updateAlarmFinished(AlarmClockData alarmClockData) {
+        openDatabase();
+        ContentValues values = getValuesFromAlarmClock(alarmClockData);
+        long id = 0;
+        mDatabase.beginTransaction();
+        try {
+            id = mDatabase.update(AlarmOpenHelper.TABLE_ALARM, values, AlarmOpenHelper.KEY_ID + "=?", new String[]{String.valueOf(alarmClockData.getId())});
+            mDatabase.setTransactionSuccessful();
+        } catch (Exception e) {
+            Log.e(TAG, "updateAlarmFinished: " + e.getMessage());
+        } finally {
+            mDatabase.endTransaction();
+        }
+        return id > 0;
+    }
+
+    public List<AlarmClockData> getOldData() {
+        List<AlarmClockData> alarmClockData = new ArrayList<>();
+        List<AlarmClockData> dataBaseAlarms = getDatabaseAlarms();
+        if (dataBaseAlarms != null && dataBaseAlarms.size() != 0) {
+            alarmClockData.addAll(dataBaseAlarms);
+        }
+        return alarmClockData;
+    }
+
+    public HashMap<Integer, AlarmClockData> getOldDataMap() {
+        List<AlarmClockData> alarmClockData = getOldData();
+        HashMap<Integer, AlarmClockData> hashMap = new HashMap<>();
+        if (alarmClockData.size() != 0) {
+            for (AlarmClockData clockData : alarmClockData) {
+                hashMap.put(clockData.getId(), clockData);
+            }
+        }
+        return hashMap;
+    }
+
+    /**
+     * 获取最近一次的闹钟
+     *
+     * @return
+     */
+    public AlarmClockData getRecentAlarmClock() {
+        List<AlarmClockData> alarmClockData = getDatabaseAlarms();
+        if (alarmClockData == null || alarmClockData.size() == 0) {
+            return null;
+        } else {
+            Collections.sort(alarmClockData, new Comparator<AlarmClockData>() {
+                @Override
+                public int compare(AlarmClockData o1, AlarmClockData o2) {
+                    if ((o1.getTimeStamp()) <= (o2.getTimeStamp())) {
+                        return 0;
+                    } else {
+                        return -1;
+                    }
+                }
+            });
+            return alarmClockData.get(0);
+        }
+    }
+
+    private HashSet<PendingIntent> getOldPendingIntentsSet() {
+        HashSet<PendingIntent> pendingIntents = new HashSet<>();
+        HashMap<Integer, AlarmClockData> data = getOldDataMap();
+        for (AlarmClockData alarmClockData : data.values()) {
+            pendingIntents.add(getPendingIntent(alarmClockData));
+        }
+        return pendingIntents;
+    }
+
+    /**
+     * 获取已设置闹钟的PendingIntent
+     *
+     * @param alarmClock
+     * @return
+     */
+    private PendingIntent getPendingIntent(AlarmClockData alarmClock) {
+        Intent intent = new Intent(MainService.ALARMWAKEUP);
+        intent.putExtra("title", alarmClock.getTitle());
+        intent.putExtra("id", alarmClock.getId());
+        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, alarmClock.getId(), intent, PendingIntent.FLAG_CANCEL_CURRENT);
+        return startPendingIntent;
+    }
+
+    private long getTimestamp(String timeString) {
+        if (TextUtils.isEmpty(timeString)) {
+            return 0;
+        }
+        if (timeString.length() == 5) {
+            String[] timeSplit = timeString.split(":");
+            int hour = Integer.parseInt(timeSplit[0]);
+            int minute = Integer.parseInt(timeSplit[1]);
+            Calendar c = Calendar.getInstance();
+            int year = c.get(Calendar.YEAR);
+            int month = c.get(Calendar.MONTH);
+            int day = c.get(Calendar.DAY_OF_MONTH);
+            c.set(year, month, day, hour, minute, 0);
+            long mTimeInfo = c.getTimeInMillis();
+            Log.e(TAG, "getTimestamp: " + mTimeInfo);
+//            long actualTime = mTimeInfo > System.currentTimeMillis() ? mTimeInfo : mTimeInfo + ONE_DAY_TIME;
+            return mTimeInfo;
+        } else {
+            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
+            try {
+                Date date = simpleDateFormat.parse(timeString);
+                long timestamp = date.getTime();
+                Log.e(TAG, "getTimestamp2: " + timestamp);
+                return timestamp;
+            } catch (ParseException e) {
+                return System.currentTimeMillis();
+            }
+        }
+    }
+
+    private long getZeroTiemstamp() {
+        //设置时区
+        Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("GMT+8"));
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        long zeroTime = calendar.getTimeInMillis();
+        Log.e(TAG, "getZeroTiemstamp: " + zeroTime);
+        return zeroTime;
+    }
+
+
+    /**
+     * 设置闹钟
+     *
+     * @param alarm
+     */
+    public void setAlarm(AlarmClockData alarm) {
+        if (pendingIntents == null) {
+            pendingIntents = getOldPendingIntentsSet();
+        }
+        int id = alarm.getId();
+        int type = alarm.getType();
+        String timeString = alarm.getTime();
+        String title = alarm.getTitle();
+        Log.e(TAG, "setAlarm: " + title);
+        long timeStamp = getTimestamp(timeString);
+        Log.e(TAG, "setAlarm: " + timeStamp);
+        boolean finished = alarm.isFinished();
+        String voiceUrl = alarm.getVoice();
+        String voiceMd5 = alarm.getVoice_md5();
+        if (!TextUtils.isEmpty(voiceUrl)) {
+            if (!FileUtil.isLocalPath(voiceUrl))
+                ariaDownload(voiceUrl, voiceMd5);
+        }
+        String fileUrl = alarm.getFile();
+        String fileMd5 = alarm.getFile_md5();
+        if (!TextUtils.isEmpty(fileUrl)) {
+            if (!FileUtil.isLocalPath(fileUrl))
+                ariaDownload(fileUrl, fileMd5);
+        }
+        switch (type) {
+            case ONCE:
+                if (!finished) {
+                    if (timeStamp < System.currentTimeMillis()) {
+                        Intent intent = new Intent(MainService.ALARMWAKEUP);
+                        intent.putExtra("title", title);
+                        intent.putExtra("id", id);
+                        mContext.sendBroadcast(intent);
+                    } else {
+                        setOnceAlarm(MainService.ALARMWAKEUP, title, id, timeStamp);
+                    }
+                }
+                break;
+            case LOOP:
+                setDayLoopAlarm(MainService.ALARMWAKEUP, title, id, timeString);
+                break;
+            case WORKING_DAY:
+                setWorkDayAlarm(MainService.ALARMWAKEUP, title, id, timeString);
+                break;
+            case OFF_DAY:
+                setOffDayAlarm(MainService.ALARMWAKEUP, title, id, timeString);
+                break;
+            default:
+        }
+    }
+
+    /**
+     * @param action
+     * @param requestCode
+     * @param timestamp   设置一次性闹钟
+     */
+    public void setOnceAlarm(String action, String extra, int requestCode, long timestamp) {
+        Intent intent = new Intent(action);
+        intent.putExtra("title", extra);
+        intent.putExtra("id", requestCode);
+        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
+        pendingIntents.add(startPendingIntent);
+        mAlarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
+        Log.e(TAG, "setOnceAlarm: " + "id: " + requestCode + " title: " + extra + " timeString: " + timestamp);
+    }
+
+    /**
+     * @param action
+     * @param requestCode
+     * @param timeString  设置循环周期为一天的闹钟
+     */
+    public void setDayLoopAlarm(String action, String extra, int requestCode, String timeString) {
+        long timestamp = getTimestamp(timeString);
+        if (System.currentTimeMillis() > timestamp) {
+            timestamp += AlarmManager.INTERVAL_DAY;
+        }
+        Intent intent = new Intent(action);
+        intent.putExtra("title", extra);
+        intent.putExtra("id", requestCode);
+        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
+        pendingIntents.add(startPendingIntent);
+        mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
+        Log.e(TAG, "setDayLoopAlarm: " + "title: " + extra + " timeString: " + timestamp);
+//        setLoopAlarm(action, extra, requestCode, AlarmManager.INTERVAL_DAY, timestamp);
+    }
+
+    /**
+     * @param action
+     * @param requestCode
+     * @param timestamp   设置循环周期为一小时的闹钟
+     */
+    public void setHourLoopAlarm(String action, String extra, int requestCode, long timestamp) {
+        setLoopAlarm(action, extra, requestCode, AlarmManager.INTERVAL_HOUR, timestamp);
+    }
+
+    /**
+     * @param action
+     * @param requestCode
+     * @param intervalMillis
+     * @param timestamp      循环闹钟
+     */
+    public void setLoopAlarm(String action, String extra, int requestCode, long intervalMillis, long timestamp) {
+        Intent intent = new Intent(action);
+        intent.putExtra("title", extra);
+        intent.putExtra("id", requestCode);
+        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
+        pendingIntents.add(startPendingIntent);
+        mAlarmManager.setWindow(AlarmManager.RTC_WAKEUP, timestamp, intervalMillis, startPendingIntent);
+        Log.e(TAG, "setLoopAlarm: " + "title: " + extra + " timeString: " + timestamp);
+    }
+
+    public void setWorkDayAlarm(String action, String extra, int requestCode, String timeString) {
+        long timestamp = getTimestamp(timeString);
+        Calendar calendar = Calendar.getInstance();
+        int day_of_week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
+        switch (day_of_week) {
+            case 6:
+            case 7:
+                timestamp += (8 - day_of_week) * AlarmManager.INTERVAL_DAY;
+                break;
+            default:
+                if (System.currentTimeMillis() > timestamp) {
+                    timestamp += AlarmManager.INTERVAL_DAY;
+                }
+                break;
+        }
+        Intent intent = new Intent(action);
+        intent.putExtra("title", extra);
+        intent.putExtra("id", requestCode);
+        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
+        pendingIntents.add(startPendingIntent);
+        mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
+        Log.e(TAG, "setWorkDayAlarm: " + "title: " + extra + " timeString: " + timestamp);
+    }
+
+    public void setOffDayAlarm(String action, String extra, int requestCode, String timeString) {
+        long timestamp = getTimestamp(timeString);
+        Calendar calendar = Calendar.getInstance();
+        int day_of_week = calendar.get(Calendar.DAY_OF_WEEK) - 1;
+        switch (day_of_week) {
+            case 6:
+                if (System.currentTimeMillis() > timestamp) {
+                    timestamp += AlarmManager.INTERVAL_DAY;
+                }
+                break;
+            case 7:
+                break;
+            default:
+                timestamp += (6 - day_of_week) * AlarmManager.INTERVAL_DAY;
+                break;
+        }
+        Intent intent = new Intent(action);
+        intent.putExtra("title", extra);
+        intent.putExtra("id", requestCode);
+        PendingIntent startPendingIntent = PendingIntent.getBroadcast(mContext, requestCode, intent, PendingIntent.FLAG_CANCEL_CURRENT);
+        pendingIntents.add(startPendingIntent);
+        mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, timestamp, startPendingIntent);
+        Log.e(TAG, "setOffDayAlarm: " + "title: " + extra + " timeString: " + timestamp);
+    }
+
+
+    public void ariaDownload(String url, String md5) {
+        String fileName = Utils.getFileNamefromURL(url);
+        File file = new File(Utils.getDownLoadPath(mContext) + fileName);
+        if (file.exists() && !file.isDirectory()) {
+            String fileMD5 = FileUtils.getFileMD5ToString(file);
+            Log.e("ariaDownload", "fileOnlineMD5=" + md5);
+            Log.e("ariaDownload", "fileMD5=" + fileMD5);
+            if (!md5.equalsIgnoreCase(fileMD5)) {
+                Aria.download(this)
+                        .load(url)     //读取下载地址
+                        .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
+//                        .ignoreFilePathOccupy()
+                        .setExtendField(md5)
+                        .create();   //启动下载}
+            } else {
+                Log.e("ariaDownload", "fileName = " + fileName + " exists");
+            }
+        } else {
+            Aria.download(this)
+                    .load(url)     //读取下载地址
+                    .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
+//                    .ignoreFilePathOccupy()
+                    .setExtendField(md5)
+                    .create();   //启动下载}
+        }
+    }
+
+    public void ariaDownload(String url) {
+        if (FileUtil.isLocalPath(url)) {
+            return;
+        }
+        String fileName = Utils.getFileNamefromURL(url);
+        File file = new File(Utils.getDownLoadPath(mContext) + fileName);
+        if (file.exists() && !file.isDirectory()) {
+            String fileMD5 = FileUtils.getFileMD5ToString(file);
+            Log.e("ariaDownload", "fileMD5=" + fileMD5);
+            Log.e("ariaDownload", "fileName = " + fileName + " exists");
+        } else {
+            Aria.download(this)
+                    .load(url)     //读取下载地址
+                    .setFilePath(Utils.getDownLoadPath(mContext) + fileName)
+                    .create();   //启动下载}
+        }
+    }
+
+
+}

app/src/main/java/com/xxpatx/os/alarm/PortAlarmAdapter.java

@@ -0,0 +1,287 @@
+package com.xxpatx.os.alarm;
+
+import android.graphics.Bitmap;
+import android.media.AudioAttributes;
+import android.media.MediaPlayer;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.constraintlayout.widget.ConstraintLayout;
+import androidx.fragment.app.FragmentActivity;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.load.resource.bitmap.RoundedCorners;
+import com.bumptech.glide.request.RequestOptions;
+import com.xxpatx.os.R;
+import com.xxpatx.os.utils.FFmpegUtils;
+import com.xxpatx.os.utils.ScreenUtils;
+import com.xxpatx.os.utils.Utils;
+import com.xxpatx.os.view.JzvdStdRound;
+import com.xxpatx.os.view.ToggleButton;
+
+import java.io.File;
+import java.io.IOException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import io.reactivex.rxjava3.core.Observer;
+import io.reactivex.rxjava3.disposables.Disposable;
+
+public class PortAlarmAdapter extends RecyclerView.Adapter<PortAlarmAdapter.holder> {
+
+    private FragmentActivity mContext;
+    private List<AlarmClockData> mAlarmClockData;
+    private OnLongClickListener mOnLongClickListener;
+
+    public void setAlarmClockData(List<AlarmClockData> alarmClockData) {
+        this.mAlarmClockData = alarmClockData;
+        notifyDataSetChanged();
+    }
+
+    public void setOnLongClickListener(OnLongClickListener onLongClickListener) {
+        this.mOnLongClickListener = onLongClickListener;
+    }
+
+    public interface OnLongClickListener {
+        void onLongClick(AlarmClockData alarmClockData);
+    }
+
+    @NonNull
+    @Override
+    public holder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+        mContext = (FragmentActivity) parent.getContext();
+        return new PortAlarmAdapter.holder(LayoutInflater.from(parent.getContext()).inflate(R.layout.item_alarm_port, parent, false));
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull holder holder, int position) {
+        AlarmClockData alarmClockData = mAlarmClockData.get(position);
+        switch (alarmClockData.getType()) {
+            case AlarmUtils.ONCE:
+                try {
+                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
+                    Date date = sdf.parse(alarmClockData.getTime());
+                    SimpleDateFormat hours = new SimpleDateFormat("HH:mm");
+                    String time = hours.format(date);
+                    holder.tv_time.setText(time);
+                } catch (ParseException e) {
+                    e.printStackTrace();
+                }
+                holder.tv_remind_type.setText("一次");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_once);
+                break;
+            case AlarmUtils.LOOP:
+                holder.tv_time.setText(alarmClockData.getTime());
+                holder.tv_remind_type.setText("每天");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_loop);
+                break;
+            case AlarmUtils.WORKING_DAY:
+                holder.tv_time.setText(alarmClockData.getTime());
+                holder.tv_remind_type.setText("周一至周五");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_work);
+                break;
+            case AlarmUtils.OFF_DAY:
+                holder.tv_time.setText(alarmClockData.getTime());
+                holder.tv_remind_type.setText("周六至周日");
+                holder.tv_remind_type.setBackgroundResource(R.drawable.tv_times_bg_offday);
+                break;
+            default:
+        }
+        String title = alarmClockData.getTitle();
+        if (TextUtils.isEmpty(title)) {
+            holder.tv_title.setText("无标题");
+        } else {
+            holder.tv_title.setText(title);
+        }
+        int is_onoff = alarmClockData.getIs_onoff();
+        holder.toggleButton2.setDisable(true);
+        if (is_onoff == 1) {
+            holder.tv_status.setText("已开启");
+            holder.toggleButton2.setToggleOn(false);
+        } else {
+            holder.tv_status.setText("已关闭");
+            holder.toggleButton2.setToggleOff(false);
+        }
+        int type = alarmClockData.getClazz();
+        switch (type){
+            case 1:
+            default:
+                holder.iv_type.setImageDrawable(mContext.getDrawable(R.drawable.icon_alarm_medicine_pressed));
+                break;
+            case 2:
+                holder.iv_type.setImageDrawable(mContext.getDrawable(R.drawable.icon_alarm_look_pressed));
+                break;
+            case 3:
+                holder.iv_type.setImageDrawable(mContext.getDrawable(R.drawable.icon_alarm_reserve_pressed));
+                break;
+        }
+        String voice = alarmClockData.getVoice();
+        if (TextUtils.isEmpty(voice)) {
+            holder.cl_voice.setVisibility(View.GONE);
+        } else {
+            holder.cl_voice.setVisibility(View.VISIBLE);
+            MediaPlayer mMediaPlayer = new MediaPlayer();
+            mMediaPlayer.setAudioAttributes(
+                    new AudioAttributes.Builder()
+                            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                            .build()
+            );
+            mMediaPlayer.setOnCompletionListener(mp -> Log.e("setOnCompletionListener", "onCompletion: "));
+            mMediaPlayer.setOnPreparedListener(mp -> Log.e("setOnPreparedListener", "onPrepared: "));
+            mMediaPlayer.setOnErrorListener((mp, what, extra) -> false);
+            //设置音频文件到MediaPlayer对象中
+            try {
+                mMediaPlayer.setDataSource(voice);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            //让MediaPlayer对象准备，用这个方法防止加载时耗时导致anr
+            mMediaPlayer.prepareAsync();
+            FFmpegUtils.getDurationInMilliseconds(voice, new Observer<Integer>() {
+                @Override
+                public void onSubscribe(@NonNull Disposable d) {
+
+                }
+
+                @Override
+                public void onNext(@NonNull Integer integer) {
+                    holder.tv_voice.setText(integer + "秒");
+                }
+
+                @Override
+                public void onError(@NonNull Throwable e) {
+
+                }
+
+                @Override
+                public void onComplete() {
+
+                }
+            });
+            holder.cl_voice.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    mMediaPlayer.start();
+                }
+            });
+        }
+        String fileUrl = alarmClockData.getFile();
+        if (TextUtils.isEmpty(fileUrl)) {
+            holder.cl_vp.setVisibility(View.GONE);
+        } else {
+            holder.cl_vp.setVisibility(View.VISIBLE);
+            if (isImgUrl(fileUrl)) {
+                holder.imageView.setVisibility(View.VISIBLE);
+                holder.jz_video.setVisibility(View.GONE);
+                if (!mContext.isDestroyed()) {
+                    RequestOptions options = new RequestOptions().transform(new RoundedCorners(ScreenUtils.dip2px(mContext, 16F)));
+                    Glide.with(mContext).load(fileUrl).apply(options).into(holder.imageView);
+                }
+            } else {
+                holder.imageView.setVisibility(View.GONE);
+                holder.jz_video.setVisibility(View.VISIBLE);
+                String fileName = Utils.getFileNamefromURL(fileUrl);
+                File file = new File(Utils.getDownLoadPath(mContext) + fileName);
+                String path;
+                if (file.exists() && !file.isDirectory()) {
+                    path = file.getAbsolutePath();
+                } else {
+                    path = fileUrl;
+                }
+                holder.jz_video.setUp(path, "");
+                holder.jz_video.startButton.setImageDrawable(mContext.getDrawable(R.drawable.play));
+                FFmpegUtils.loadVideoScreenshot(path, new Observer<Bitmap>() {
+                    @Override
+                    public void onSubscribe(@NonNull Disposable d) {
+
+                    }
+
+                    @Override
+                    public void onNext(@NonNull Bitmap bitmap) {
+                        if (!mContext.isDestroyed()) {
+                            RequestOptions options = new RequestOptions().transform(new RoundedCorners(ScreenUtils.dip2px(mContext, 16F)));
+                            Glide.with(mContext).load(bitmap).apply(options).into(holder.jz_video.posterImageView);
+//                            Glide.with(mContext).load(bitmap).into(holder.imageView);
+                        }
+                        holder.jz_video.startButton.setImageDrawable(mContext.getDrawable(R.drawable.play));
+                    }
+
+                    @Override
+                    public void onError(@NonNull Throwable e) {
+
+                    }
+
+                    @Override
+                    public void onComplete() {
+
+                    }
+                });
+
+            }
+        }
+        holder.root.setOnLongClickListener(new View.OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View view) {
+                mOnLongClickListener.onLongClick(alarmClockData);
+                return false;
+            }
+        });
+        holder.root.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+//                Intent intent = new Intent(mContext, AlarmClockEditActivity.class);
+//                intent.putExtra("id", alarmClockData.getId());
+//                mContext.startActivity(intent);
+            }
+        });
+
+    }
+
+    private Pattern mCompile = Pattern.compile(".*?(gif|jpeg|png|jpg|bmp|webp)");
+
+    private boolean isImgUrl(String url) {
+        if (TextUtils.isEmpty(url) || url.trim().length() == 0) {
+            return false;
+        }
+        return mCompile.matcher(url).matches();
+    }
+
+    @Override
+    public int getItemCount() {
+        return mAlarmClockData == null ? 0 : mAlarmClockData.size();
+    }
+
+    class holder extends RecyclerView.ViewHolder {
+        TextView tv_time, tv_remind_type, tv_title, tv_voice, tv_status;
+        ConstraintLayout cl_voice, cl_vp, root;
+        JzvdStdRound jz_video;
+        ImageView imageView,iv_type;
+        ToggleButton toggleButton2;
+
+        public holder(@NonNull View itemView) {
+            super(itemView);
+            tv_time = itemView.findViewById(R.id.tv_time);
+            tv_remind_type = itemView.findViewById(R.id.tv_remind_type);
+            tv_title = itemView.findViewById(R.id.tv_title);
+            tv_voice = itemView.findViewById(R.id.tv_voice);
+            cl_voice = itemView.findViewById(R.id.cl_voice);
+            cl_vp = itemView.findViewById(R.id.cl_vp);
+            root = itemView.findViewById(R.id.root);
+            jz_video = itemView.findViewById(R.id.jz_video);
+            imageView = itemView.findViewById(R.id.imageView);
+            iv_type = itemView.findViewById(R.id.iv_type);
+            tv_status = itemView.findViewById(R.id.tv_status);
+            toggleButton2 = itemView.findViewById(R.id.toggleButton2);
+        }
+    }
+}