package com.seewo.vcommons.system.onoffsetting;

import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.os.SystemProperties;
import android.util.Log;
import com.seewo.vcommons.constants.Platform;
import com.seewo.vcommons.cutomer.CustomerUtils;
import com.seewo.vcommons.data.PropertiesUtils;
import com.seewo.vcommons.data.UserContentResolver;
import com.seewo.vcommons.system.onoffsetting.Task;
import com.seewo.vcommons.utils.BoardTypeUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
public class TimeSwitchSQLBusiness {
    private static final String DEFAULT_SIGNS_FOR_WEEKDAYS = "0000000";
    public static final String KEY_SUPPORT_REBOOT_TASK = "persist.sys.support_reboot_task";
    private static final int PRIVATE_TIMER_INDEX = 0;
    public static final String REGULAR_ALL_SHUTDOWN = "0+";
    public static final String REGULAR_ALL_STARTUP = "1+";
    public static final String REGULAR_ALTERNATE = "(01)+|(10)+";
    public static final String REGULAR_CORRECTION = "(0+|1+)|(01)+|(10)+";
    public static final boolean SUPPORT_REBOOT_TASK;
    private static String TAG = null;
    public static final int TIMER_COUNT;
    private static final int TIMER_INDEX = 1;
    private static final String TYPE_SHUTDOWN = "0";
    private static final String TYPE_STARTUP = "1";
    public static final Uri mUri;
    private static UserContentResolver sUserContentResolver;

    static {
        int i;
        if (CustomerUtils.isBenqCustomized() || CustomerUtils.isViewSonicBiaopaiCustomized()) {
            i = 8;
        } else {
            i = SystemProperties.getInt(BoardTypeUtils.isCtmProperty() ? "persist.ctm.time_switch_max" : "persist.sys.time_switch_max", Platform.UNKNOWN);
        }
        TIMER_COUNT = i;
        TAG = "raymond";
        mUri = Constants.TASK_URI;
        SUPPORT_REBOOT_TASK = PropertiesUtils.getProperty(KEY_SUPPORT_REBOOT_TASK, false);
    }

    private static ContentValues createContentValues(Task task) {
        ContentValues contentValues = new ContentValues(Task.TaskColumns.COLUMN_COUNT);
        contentValues.put(Task.TaskColumns.GROUP_ID, Integer.valueOf(task.groupId));
        contentValues.put(Task.TaskColumns.STARTUP_HOUR, Integer.valueOf(task.startupHour));
        contentValues.put(Task.TaskColumns.STARTUP_MINUTES, Integer.valueOf(task.startupMinute));
        contentValues.put(Task.TaskColumns.SHUTDOWN_HOUR, Integer.valueOf(task.shutdownHour));
        contentValues.put(Task.TaskColumns.SHUTDOWN_MINUTES, Integer.valueOf(task.shutdownMinute));
        contentValues.put(Task.TaskColumns.DAYS_OF_WEEK, task.daysOfWeek);
        contentValues.put(Task.TaskColumns.STARTUP_DAYS, task.startupDays);
        contentValues.put(Task.TaskColumns.SHUTDOWN_DAYS, task.shutdownDays);
        contentValues.put(Task.TaskColumns.MESSAGE, task.message);
        contentValues.put("command", task.command);
        contentValues.put(Task.TaskColumns.CUSTOM_CLOUMN_FORCE_CHANNEL, task.forceChannel);
        contentValues.put(Task.TaskColumns.ENABLED, Integer.valueOf(task.enabled ? 1 : 0));
        contentValues.put(Task.TaskColumns.CUSTOM_AUTO_PLEY, Integer.valueOf(task.autoPlay ? 1 : 0));
        contentValues.put(Task.TaskColumns.CUSTOM_OPEN_APP, Integer.valueOf(task.openApp ? 1 : 0));
        if (SUPPORT_REBOOT_TASK) {
            contentValues.put(Task.TaskColumns.REBOOT_DAYS, task.rebootDays);
            contentValues.put(Task.TaskColumns.REBOOT_HOUR, Integer.valueOf(task.rebootHour));
            contentValues.put(Task.TaskColumns.REBOOT_MINUTES, Integer.valueOf(task.rebootMinute));
        }
        return contentValues;
    }

    public static UserContentResolver getContentResolver(Context context) {
        if (sUserContentResolver == null) {
            sUserContentResolver = new UserContentResolver(context, 0);
        }
        return sUserContentResolver;
    }

    public static List<Task> getTasksList(ContentResolver contentResolver) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, null, null, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                task.autoPlay = cursorQuery.getInt(13) == 1;
                task.openApp = cursorQuery.getInt(14) == 1;
                if (SUPPORT_REBOOT_TASK) {
                    task.rebootDays = cursorQuery.getString(15);
                    task.rebootHour = cursorQuery.getInt(16);
                    task.rebootMinute = cursorQuery.getInt(17);
                }
                if (task.groupId != 0) {
                    arrayList.add(task);
                }
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getTasksListExceptGID(ContentResolver contentResolver, int i) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "group_id!=?", new String[]{Integer.toString(i)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                task.autoPlay = cursorQuery.getInt(13) == 1;
                task.openApp = cursorQuery.getInt(14) == 1;
                if (SUPPORT_REBOOT_TASK) {
                    task.rebootDays = cursorQuery.getString(15);
                    task.rebootHour = cursorQuery.getInt(16);
                    task.rebootMinute = cursorQuery.getInt(17);
                }
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    private static Cursor getTasksCursor(ContentResolver contentResolver) {
        Log.d(TAG, "getTasksCursor: " + TIMER_COUNT);
        Cursor cursorQuery = contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, null, null, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            return cursorQuery;
        }
        return null;
    }

    public static Cursor getTasksCursor(Context context) {
        return getTasksCursor(getContentResolver(context));
    }

    public static Task getTaskByID(ContentResolver contentResolver, int i) {
        Cursor cursorQuery = contentResolver.query(ContentUris.withAppendedId(mUri, i), Task.TaskColumns.TASK_QUERY_COLUMNS, null, null, null);
        if (cursorQuery != null) {
            task = cursorQuery.moveToFirst() ? new Task(cursorQuery) : null;
            cursorQuery.close();
        }
        return task;
    }

    public static Task getTaskByGroupID(Context context, int i) {
        if (i == -1) {
            return null;
        }
        Cursor cursorQuery = getContentResolver(context).query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "group_id=?", new String[]{Integer.toString(i)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            task = cursorQuery.moveToFirst() ? new Task(cursorQuery) : null;
            cursorQuery.close();
        }
        return task;
    }

    public static Cursor getEnableTasksCursor(ContentResolver contentResolver) {
        return contentResolver.query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "enabled=?", new String[]{Integer.toString(1)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
    }

    public static void addTaskById(Context context, Task task) {
        Task taskByGroupID = getTaskByGroupID(context, task.groupId);
        if (taskByGroupID == null) {
            Log.d(TAG, "addTask: insert");
            getContentResolver(context).insert(mUri, createContentValues(task));
        } else {
            Log.d(TAG, "addTask: update by group id");
            task.id = taskByGroupID.id;
            updateTask(context, task);
        }
    }

    public static void addTask(Context context, Task task) {
        if (getTaskByGroupID(context, task.groupId) == null) {
            Log.d(TAG, "addTask: insert");
            getContentResolver(context).insert(mUri, createContentValues(task));
        } else {
            Log.d(TAG, "addTask: update by group id");
            updateTaskByGroupID(context, task);
        }
    }

    public static void deleteTaskByID(Context context, int i) {
        if (i == -1) {
            return;
        }
        getContentResolver(context).delete(ContentUris.withAppendedId(mUri, i), "", null);
    }

    public static void deleteAll(Context context) {
        getContentResolver(context).delete(mUri, "_id>-1", null);
    }

    public static void deleteTaskByGroupID(Context context, int i) {
        if (i == -1) {
            return;
        }
        getContentResolver(context).delete(mUri, "group_id = " + i, null);
    }

    public static void updateTask(Context context, Task task) {
        getContentResolver(context).update(ContentUris.withAppendedId(mUri, task.id), createContentValues(task), null, null);
    }

    public static void updateTaskByGroupID(Context context, Task task) {
        getContentResolver(context).update(ContentUris.withAppendedId(mUri, task.groupId), createContentValues(task), "group_id = " + task.groupId, null);
    }

    public static String getTimerTaskChannelNameByGID(Context context, int i) {
        Cursor cursorQuery = getContentResolver(context).query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "group_id=? and enabled=?", new String[]{Integer.toString(i), "1"}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        String string = "";
        if (cursorQuery != null) {
            if (cursorQuery.moveToFirst()) {
                string = cursorQuery.getString(12);
            }
            cursorQuery.close();
        }
        return string;
    }

    public static void enableTask(Context context, int i, boolean z) {
        enableTaskInternal(context, i, z);
    }

    private static void enableTaskInternal(Context context, int i, boolean z) {
        enableTaskInternal(context, getTaskByID(getContentResolver(context), i), z);
    }

    private static void enableTaskInternal(Context context, Task task, boolean z) {
        if (task == null) {
            return;
        }
        UserContentResolver contentResolver = getContentResolver(context);
        ContentValues contentValues = new ContentValues(2);
        contentValues.put(Task.TaskColumns.ENABLED, Integer.valueOf(z ? 1 : 0));
        contentResolver.update(ContentUris.withAppendedId(mUri, task.id), contentValues, null, null);
    }

    public static int getMaxSupportedPowerControlTaskNumber() {
        return TIMER_COUNT - 1;
    }

    public static int getAvailableGroupID(Context context) {
        int i;
        Log.d(TAG, "getAvailableGroupID: count " + TIMER_COUNT);
        int maxSupportedPowerControlTaskNumber = getMaxSupportedPowerControlTaskNumber();
        Cursor tasksCursor = getTasksCursor(getContentResolver(context));
        int i2 = -1;
        if (tasksCursor == null) {
            return -1;
        }
        if (tasksCursor.getCount() == 0) {
            return 1;
        }
        if (tasksCursor.getCount() >= maxSupportedPowerControlTaskNumber) {
            return -1;
        }
        int i3 = 1;
        while (true) {
            if (i3 >= maxSupportedPowerControlTaskNumber + 1) {
                break;
            }
            tasksCursor.moveToFirst();
            do {
                i = tasksCursor.getInt(1);
                if (i == i3) {
                    break;
                }
            } while (tasksCursor.moveToNext());
            if (tasksCursor.isAfterLast() && i != i3) {
                i2 = i3;
                break;
            }
            i3++;
        }
        tasksCursor.close();
        return i2;
    }

    public int[] isOKBeforUpdateDB(Context context, Task task) {
        String[] strArr;
        int i = 7;
        int[] iArr = {-1, -1, -1, -1, -1, -1, -1};
        Cursor enableTasksCursor = getEnableTasksCursor(getContentResolver(context));
        if (enableTasksCursor != null && enableTasksCursor.getCount() != 0) {
            int count = enableTasksCursor.getCount();
            HashMap<String, String> map = new HashMap<>();
            int i2 = 6;
            int i3 = 5;
            int i4 = 2;
            int iWhenTaskMapNotEmpty = 0;
            String[] strArr2 = (CustomerUtils.isBenqCustomized() || CustomerUtils.isViewSonicBiaopaiCustomized()) ? new String[]{"0000000", "0000000", "0000000", "0000000", "0000000", "0000000", "0000000"} : new String[]{"0000000", "0000000", "0000000"};
            String[] strArr3 = new String[count];
            String[] strArr4 = new String[count];
            String strChangTimeFromIntToStr = changTimeFromIntToStr(task.startupHour, task.startupMinute);
            String strChangTimeFromIntToStr2 = changTimeFromIntToStr(task.shutdownHour, task.shutdownMinute);
            enableTasksCursor.moveToFirst();
            int i5 = 0;
            while (!enableTasksCursor.isAfterLast()) {
                String string = enableTasksCursor.getString(i4);
                int i6 = enableTasksCursor.getInt(i3);
                int i7 = enableTasksCursor.getInt(i2);
                int i8 = enableTasksCursor.getInt(i);
                int i9 = enableTasksCursor.getInt(8);
                strArr2[i5] = string;
                strArr3[i5] = changTimeFromIntToStr(i6, i7);
                strArr4[i5] = changTimeFromIntToStr(i8, i9);
                i5++;
                enableTasksCursor.moveToNext();
                i = 7;
                i2 = 6;
                i3 = 5;
                i4 = 2;
            }
            int i10 = 0;
            while (i10 < task.daysOfWeek.length()) {
                if (task.daysOfWeek.charAt(i10) == '1') {
                    strArr = strArr4;
                    int i11 = i10;
                    forDaysOfWeek(task, map, strArr2, strArr3, strArr4, i11);
                    iWhenTaskMapNotEmpty = whenTaskMapNotEmpty(map, strChangTimeFromIntToStr, strChangTimeFromIntToStr2, iArr, iWhenTaskMapNotEmpty, i11);
                    map.clear();
                } else {
                    strArr = strArr4;
                }
                i10++;
                strArr4 = strArr;
            }
            enableTasksCursor.close();
        }
        return iArr;
    }

    private int whenTaskMapNotEmpty(HashMap<String, String> map, String str, String str2, int[] iArr, int i, int i2) {
        if (map.size() == 0) {
            return i;
        }
        if (Integer.valueOf(str).intValue() > 0) {
            map.put(str, "1");
        }
        if (Integer.valueOf(str2).intValue() > 0) {
            map.put(str2, "0");
        }
        if (checkOrder(orderTheMapSet(map))) {
            return i;
        }
        iArr[i] = i2;
        Log.d(TAG, "errorDays[" + i + "]: " + iArr[i]);
        return i + 1;
    }

    private void forDaysOfWeek(Task task, HashMap<String, String> map, String[] strArr, String[] strArr2, String[] strArr3, int i) {
        for (int i2 = 0; i2 < strArr.length; i2++) {
            if (strArr[i2].charAt(i) == task.daysOfWeek.charAt(i)) {
                if (Integer.valueOf(strArr2[i2]).intValue() > 0) {
                    map.put(strArr2[i2], "1");
                }
                if (Integer.valueOf(strArr3[i2]).intValue() > 0) {
                    map.put(strArr3[i2], "0");
                }
            }
        }
    }

    private String changTimeFromIntToStr(int i, int i2) {
        return Integer.toString((i * 60) + i2);
    }

    private String orderTheMapSet(HashMap<String, String> map) {
        ArrayList arrayList = new ArrayList(map.entrySet());
        StringBuilder sb = new StringBuilder();
        Collections.sort(arrayList, new Comparator<Map.Entry<String, String>>() { // from class: com.seewo.vcommons.system.onoffsetting.TimeSwitchSQLBusiness.1
            @Override // java.util.Comparator
            public int compare(Map.Entry<String, String> entry, Map.Entry<String, String> entry2) {
                return Integer.valueOf(entry.getKey()).compareTo(Integer.valueOf(entry2.getKey()));
            }
        });
        arrayList.size();
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            sb.append((String) ((Map.Entry) it.next()).getValue());
        }
        return sb.toString();
    }

    private boolean checkOrder(String str) {
        Log.d(TAG, "Order sourceStr:" + str);
        return Pattern.compile(REGULAR_CORRECTION).matcher(str).matches();
    }

    public static boolean checkTheIntervalBetweenStartupAndShutdown(Context context, Task task) {
        List<Integer> allStartupTimeFromTask = getAllStartupTimeFromTask(task);
        List<Integer> allShutdownTimeFromTask = getAllShutdownTimeFromTask(task);
        if (!isAvailableTimeInterval(allStartupTimeFromTask, allShutdownTimeFromTask)) {
            return false;
        }
        List<Task> tasksListExceptGID = getTasksListExceptGID(getContentResolver(context), task.groupId);
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        for (int i = 0; i < tasksListExceptGID.size(); i++) {
            arrayList.addAll(getAllStartupTimeFromTask(tasksListExceptGID.get(i)));
            arrayList2.addAll(getAllShutdownTimeFromTask(tasksListExceptGID.get(i)));
        }
        return isAvailableTimeInterval(allStartupTimeFromTask, arrayList2) && isAvailableTimeInterval(arrayList, allShutdownTimeFromTask);
    }

    public static boolean checkTheIntervalBetweenStartupAndReboot(Context context, Task task) {
        if (!SUPPORT_REBOOT_TASK) {
            return true;
        }
        List<Integer> allStartupTimeFromTask = getAllStartupTimeFromTask(task);
        List<Integer> allRebootTimeFromTask = getAllRebootTimeFromTask(task);
        if (!isAvailableTimeInterval(allStartupTimeFromTask, allRebootTimeFromTask)) {
            return false;
        }
        List<Task> tasksListExceptGID = getTasksListExceptGID(getContentResolver(context), task.groupId);
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        for (int i = 0; i < tasksListExceptGID.size(); i++) {
            arrayList.addAll(getAllStartupTimeFromTask(tasksListExceptGID.get(i)));
            arrayList2.addAll(getAllRebootTimeFromTask(tasksListExceptGID.get(i)));
        }
        return isAvailableTimeInterval(allStartupTimeFromTask, arrayList2) && isAvailableTimeInterval(arrayList, allRebootTimeFromTask);
    }

    public static boolean checkTheIntervalBetweenShutdownAndReboot(Context context, Task task) {
        if (!SUPPORT_REBOOT_TASK) {
            return true;
        }
        List<Integer> allShutdownTimeFromTask = getAllShutdownTimeFromTask(task);
        List<Integer> allRebootTimeFromTask = getAllRebootTimeFromTask(task);
        if (!isAvailableTimeInterval(allShutdownTimeFromTask, allRebootTimeFromTask)) {
            return false;
        }
        List<Task> tasksListExceptGID = getTasksListExceptGID(getContentResolver(context), task.groupId);
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        for (int i = 0; i < tasksListExceptGID.size(); i++) {
            arrayList.addAll(getAllShutdownTimeFromTask(tasksListExceptGID.get(i)));
            arrayList2.addAll(getAllRebootTimeFromTask(tasksListExceptGID.get(i)));
        }
        return isAvailableTimeInterval(allShutdownTimeFromTask, arrayList2) && isAvailableTimeInterval(arrayList, allRebootTimeFromTask);
    }

    private static List<Integer> getAllStartupTimeFromTask(Task task) {
        ArrayList arrayList = new ArrayList();
        int i = (task.startupHour * 60) + task.startupMinute;
        String str = task.startupDays;
        for (int i2 = 0; i2 < 7; i2++) {
            if (str.charAt(i2) == '1' && i != -61) {
                arrayList.add(Integer.valueOf((i2 * 1440) + i));
            }
        }
        return arrayList;
    }

    private static List<Integer> getAllShutdownTimeFromTask(Task task) {
        ArrayList arrayList = new ArrayList();
        int i = (task.shutdownHour * 60) + task.shutdownMinute;
        String str = task.shutdownDays;
        for (int i2 = 0; i2 < 7; i2++) {
            if (str.charAt(i2) == '1' && i != -61) {
                arrayList.add(Integer.valueOf((i2 * 1440) + i));
            }
        }
        return arrayList;
    }

    private static List<Integer> getAllRebootTimeFromTask(Task task) {
        ArrayList arrayList = new ArrayList();
        if (!SUPPORT_REBOOT_TASK) {
            return arrayList;
        }
        int i = (task.rebootHour * 60) + task.rebootMinute;
        String str = task.rebootDays;
        for (int i2 = 0; i2 < 7; i2++) {
            if (str.charAt(i2) == '1' && i != -61) {
                arrayList.add(Integer.valueOf((i2 * 1440) + i));
            }
        }
        return arrayList;
    }

    private static boolean isAvailableTimeInterval(List<Integer> list, List<Integer> list2) {
        for (Integer num : list) {
            for (Integer num2 : list2) {
                if (Math.abs(num.intValue() - num2.intValue()) % 10080 < Constants.INTERVAL_BETWEEN_STARTUP_AND_SHUTDOWN || 10080 - Math.abs(num.intValue() - num2.intValue()) < Constants.INTERVAL_BETWEEN_STARTUP_AND_SHUTDOWN) {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean checkTheIntervalBetweenShutdown(Context context, Task task) {
        List<Integer> allShutdownTimeFromTask = getAllShutdownTimeFromTask(task);
        ArrayList arrayList = new ArrayList();
        List<Task> tasksListExceptGID = getTasksListExceptGID(getContentResolver(context), task.groupId);
        for (int i = 0; i < tasksListExceptGID.size(); i++) {
            arrayList.addAll(getAllShutdownTimeFromTask(tasksListExceptGID.get(i)));
        }
        return isAvailableTimeInterval(allShutdownTimeFromTask, arrayList);
    }

    public static List<Task> getEnableShutdownTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = getContentResolver(context).query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "shutdown_hour!=? and enabled=?", new String[]{Integer.toString(-1), "1"}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                task.autoPlay = cursorQuery.getInt(13) == 1;
                task.openApp = cursorQuery.getInt(14) == 1;
                if (SUPPORT_REBOOT_TASK) {
                    task.rebootDays = cursorQuery.getString(15);
                    task.rebootHour = cursorQuery.getInt(16);
                    task.rebootMinute = cursorQuery.getInt(17);
                }
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getShutdownTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = getContentResolver(context).query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "shutdown_hour!=? ", new String[]{Integer.toString(-1)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                task.autoPlay = cursorQuery.getInt(13) == 1;
                task.openApp = cursorQuery.getInt(14) == 1;
                if (SUPPORT_REBOOT_TASK) {
                    task.rebootDays = cursorQuery.getString(15);
                    task.rebootHour = cursorQuery.getInt(16);
                    task.rebootMinute = cursorQuery.getInt(17);
                }
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getEnableStartupTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = getContentResolver(context).query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "startup_hour!=? and enabled=?", new String[]{Integer.toString(-1), "1"}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                task.autoPlay = cursorQuery.getInt(13) == 1;
                task.openApp = cursorQuery.getInt(14) == 1;
                if (SUPPORT_REBOOT_TASK) {
                    task.rebootDays = cursorQuery.getString(15);
                    task.rebootHour = cursorQuery.getInt(16);
                    task.rebootMinute = cursorQuery.getInt(17);
                }
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getStartupTasksList(Context context) {
        ArrayList arrayList = new ArrayList();
        Cursor cursorQuery = getContentResolver(context).query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "startup_hour!=?", new String[]{Integer.toString(-1)}, Task.TaskColumns.DEFAULT_SORT_ORDER);
        if (cursorQuery != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                task.autoPlay = cursorQuery.getInt(13) == 1;
                task.openApp = cursorQuery.getInt(14) == 1;
                if (SUPPORT_REBOOT_TASK) {
                    task.rebootDays = cursorQuery.getString(15);
                    task.rebootHour = cursorQuery.getInt(16);
                    task.rebootMinute = cursorQuery.getInt(17);
                }
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }

    public static List<Task> getEnableRebootTasksList(Context context) {
        Cursor cursorQuery;
        ArrayList arrayList = new ArrayList();
        if (SUPPORT_REBOOT_TASK && (cursorQuery = getContentResolver(context).query(mUri, Task.TaskColumns.TASK_QUERY_COLUMNS, "reboot_hour!=? and enabled=?", new String[]{Integer.toString(-1), "1"}, Task.TaskColumns.DEFAULT_SORT_ORDER)) != null) {
            cursorQuery.moveToFirst();
            while (!cursorQuery.isAfterLast()) {
                Task task = new Task();
                task.id = cursorQuery.getInt(0);
                task.groupId = cursorQuery.getInt(1);
                task.daysOfWeek = cursorQuery.getString(2);
                task.startupDays = cursorQuery.getString(3);
                task.shutdownDays = cursorQuery.getString(4);
                task.startupHour = cursorQuery.getInt(5);
                task.startupMinute = cursorQuery.getInt(6);
                task.shutdownHour = cursorQuery.getInt(7);
                task.shutdownMinute = cursorQuery.getInt(8);
                task.enabled = cursorQuery.getInt(11) == 1;
                task.message = cursorQuery.getString(9);
                task.command = cursorQuery.getString(10);
                task.forceChannel = cursorQuery.getString(12);
                task.autoPlay = cursorQuery.getInt(13) == 1;
                task.openApp = cursorQuery.getInt(14) == 1;
                task.rebootDays = cursorQuery.getString(15);
                task.rebootHour = cursorQuery.getInt(16);
                task.rebootMinute = cursorQuery.getInt(17);
                arrayList.add(task);
                cursorQuery.moveToNext();
            }
            cursorQuery.close();
        }
        return arrayList;
    }
}