utils.cpp

来自「funambol window mobile客户端源代码」· C++ 代码 · 共 2,314 行 · 第 1/5 页

                    occurences = _wtol(token);
                    if(occurences == 0)
                        pRecPat->put_NoEndDate(VARIANT_TRUE);
                    else
                        pRecPat->put_Occurrences(occurences);
                    pRecPat->put_Interval(interval);
                    if(wcscmp(days, TEXT("")))
                        pRecPat->put_DayOfWeekMask(calculateDayOfWeek(days));
                    else
                        pRecPat->put_DayOfWeekMask(getWeekDay(startDate));
                }
                else if(token[8] == TEXT('T')) {
                    pRecPat->put_RecurrenceType(recType);
                    systemTimeToDouble(token, &endDate, NULL);
                    pRecPat->put_PatternEndDate(endDate);
                    pRecPat->put_Interval(interval);
                    if(wcscmp(days, TEXT("")))
                        pRecPat->put_DayOfWeekMask(calculateDayOfWeek(days));
                    else
                        pRecPat->put_DayOfWeekMask(getWeekDay(startDate));
                }
                else if(isDayOfWeek(token)) {
                     wcscat(days, token);
                    wcscat(days, TEXT(" "));
                }
            }
            else if(recType == olRecursMonthly) {
                //VCalendar supports as Monthly by day rules: MD<interval> listofdates|listofdates(from end of month) <end tag>
                //On outlook recurrence pattern only MD<interval> day <end tag> can be represented
                if(wcschr(token, TEXT('#'))) {
                    pRecPat->put_RecurrenceType(recType);
                    token++;
                    occurences = _wtol(token);
                    if(occurences == 0)
                        pRecPat->put_NoEndDate(VARIANT_TRUE);
                    else
                        pRecPat->put_Occurrences(occurences);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_DayOfMonth(dayOfMonth);
                }
                else if(token[8] == TEXT('T')) {
                    pRecPat->put_RecurrenceType(recType);
                    systemTimeToDouble(token, &endDate, NULL);
                    pRecPat->put_PatternEndDate(endDate);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_DayOfMonth(dayOfMonth);
                }
                else {
                    if(dayOfMonth != -1) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                    dayOfMonth = _wtol(token);
                    if(dayOfMonth == 0) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                }
            }
            else if(recType == olRecursMonthNth) {
                if(wcschr(token, TEXT('#'))) {
                    pRecPat->put_RecurrenceType(recType);
                    token++;
                    occurences = _wtol(token);
                    if(occurences == 0)
                        pRecPat->put_NoEndDate(VARIANT_TRUE);
                    else
                        pRecPat->put_Occurrences(occurences);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_Instance(weekOfMonth);
                    pRecPat->put_DayOfWeekMask(calculateDayOfWeek(days));
                }
                else if(token[8] == TEXT('T')) {
                    pRecPat->put_RecurrenceType(recType);
                    systemTimeToDouble(token, &endDate, NULL);
                    pRecPat->put_PatternEndDate(endDate);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_Instance(weekOfMonth);
                    pRecPat->put_DayOfWeekMask(calculateDayOfWeek(days));
                }
                else if(isDayOfWeek(token)) {
                     wcscat(days, token);
                    wcscat(days, TEXT(" "));
                }
                else {
                    if(token[1] != TEXT('+') && token[1] != TEXT('-')) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                    wchar_t sWeek[] = TEXT("\0\0");
                    sWeek[0] = token[0];
                    weekOfMonth = _wtol(sWeek);
                    if(token[1] == TEXT('-'))
                        weekOfMonth = 5 - weekOfMonth;
                    if(weekOfMonth > 5 || weekOfMonth < 1) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                }
            }
            else if(recType == olRecursYearly) {
                //expected sequence will be YM1 month <end tag>
                if(wcschr(token, TEXT('#'))) {
                    pRecPat->put_RecurrenceType(recType);
                    token++;
                    occurences = _wtol(token);
                    if(occurences == 0)
                        pRecPat->put_NoEndDate(VARIANT_TRUE);
                    else
                        pRecPat->put_Occurrences(occurences);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_MonthOfYear(monthOfYear);
                    pRecPat->put_DayOfMonth(dayOfMonth);
                }
                else if(token[8] == TEXT('T')) {
                    pRecPat->put_RecurrenceType(recType);
                    systemTimeToDouble(token, &endDate, NULL);
                    pRecPat->put_PatternEndDate(endDate);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_MonthOfYear(monthOfYear);
                    pRecPat->put_DayOfMonth(dayOfMonth);
                }
                else {
                    if(wcscmp(mOfYear, TEXT(""))) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                     wcscat(mOfYear, token);
                    monthOfYear = _wtol(mOfYear);
                    SYSTEMTIME st;
                    VariantTimeToSystemTime(startDate, &st);
                    dayOfMonth = st.wDay;
                }
            }
        }
    }

    return ret;
}
wchar_t* extractRrule(IRecurrencePattern* pRecPat) {

    wchar_t* recurrence = new wchar_t[100];
    wcscpy(recurrence, TEXT(""));
    DATE patStartDate;

    // Note: PatternEndDate is no more sent to Server (using only Occurrences)

    long recType;
    pRecPat->get_RecurrenceType(&recType);
    pRecPat->get_PatternStartDate(& patStartDate);

    VARIANT_BOOL noEnd;
    pRecPat->get_NoEndDate(&noEnd);

    long interval;
    pRecPat->get_Interval(&interval);

    long occurences;
    pRecPat->get_Occurrences(&occurences);

    long dayofweek;
    pRecPat->get_DayOfWeekMask(&dayofweek);

    long dayofmonth;
    pRecPat->get_DayOfMonth(& dayofmonth);

    //week of month
    long instance;
    pRecPat->get_Instance(&instance);

    long duration;
    pRecPat->get_Duration(&duration);

    long monthofyear;
    pRecPat->get_MonthOfYear(&monthofyear);

    switch(recType) {
            case olRecursDaily:
                if(noEnd == VARIANT_TRUE)
                    occurences = 0;  //occurences are -1 in this case but we use 0 to indicate event that does not end
                if(interval >0)
                        wsprintf(recurrence, TEXT("D%ld #%ld"), interval, occurences);
                else if (dayofweek > 0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if (days) {
                        wsprintf(recurrence, TEXT("W1 %s #%ld"), days, occurences);
                        delete [] days;
                    }
                }
                break;
            case olRecursWeekly:
                if (dayofweek > 0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if (days) {
                        if(noEnd == VARIANT_TRUE)
                            wsprintf(recurrence, TEXT("W%ld %s #0"), interval, days);
                        else {
                            wsprintf(recurrence, TEXT("W%ld %s #%ld"), interval, days, occurences);
                            delete [] days;
                        }
                    }
                }
                break;
            case olRecursMonthly:
                if(dayofmonth > 0)
                    if(noEnd == VARIANT_TRUE)
                            wsprintf(recurrence, TEXT("MD%ld %ld #0"), interval, dayofmonth);
                        else {
                            wsprintf(recurrence, TEXT("MD%ld %ld #%ld"), interval, dayofmonth, occurences);
                        }
                break;
            case olRecursMonthNth:
                if(instance > 0 && dayofweek >0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if(days)
                        if(noEnd == VARIANT_TRUE)
                                wsprintf(recurrence, TEXT("MP%ld %ld+ %s #0"), interval, instance, days);
                            else {
                                wsprintf(recurrence, TEXT("MP%ld %ld+ %s #%ld"), interval, instance, days, occurences);
                            }
                    if(days)
                        delete [] days;
                }
                break;
            case olRecursYearly:
                if(dayofmonth > 0 && monthofyear > 0)
                    if(noEnd == VARIANT_TRUE)
                        wsprintf(recurrence, TEXT("YM1 %ld #0"), monthofyear);
                    else
                        wsprintf(recurrence, TEXT("YM1 %ld #%ld"), monthofyear, occurences);
                break;
            case olRecursYearNth:
                if(dayofweek > 0 && instance >0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if(days)
                        if(noEnd == VARIANT_TRUE)
                            wsprintf(recurrence, TEXT("MP12 %ld+ %s #0"), instance, days);
                            else {
                                wsprintf(recurrence, TEXT("MP12 %ld+ %s #%ld"), instance, days, occurences);
                            }
                    if(days)
                        delete [] days;
                }
                break;
        }

    return recurrence;
}

wchar_t* extractDayOfWeek(long l) {
    /*
        enum OlDaysOfWeek {
          olSunday    = 1,
          olMonday    = 2,
          olTuesday   = 4,
          olWednesday = 8,
          olThursday  = 16,
          olFriday    = 32,
          olSaturday  = 64,
        };

        */
    if (l<0 || l>128)
        return NULL;

    //SU MO TU WE TH FR SA

    wchar_t* ret = new wchar_t[21];
    wcscpy(ret, TEXT(""));

    if(l & olSunday)
        wcscat(ret, TEXT("SU "));
    if(l & olMonday)
        wcscat(ret, TEXT("MO "));
    if(l & olTuesday)
        wcscat(ret, TEXT("TU "));
    if(l & olWednesday)
        wcscat(ret, TEXT("WE "));
    if(l & olThursday)
        wcscat(ret, TEXT("TH "));
    if(l & olFriday)
        wcscat(ret, TEXT("FR "));
    if(l & olSaturday)
        wcscat(ret, TEXT("SA "));

    return ret;

}
long calculateDayOfWeek(wchar_t* in) {

    long ret = 0;

    wchar_t* index;
    index = NULL;
    index = wcsstr(in, TEXT("SU"));
    if(index)
        ret += olSunday;

    index = NULL;
    index = wcsstr(in, TEXT("MO"));
    if(index)
        ret += olMonday;

    index = NULL;
    index = wcsstr(in, TEXT("TU"));
    if(index)
        ret += olTuesday;

    index = NULL;
    index = wcsstr(in, TEXT("WE"));
    if(index)
        ret += olWednesday;

    index = NULL;
    index = wcsstr(in, TEXT("TH"));
    if(index)
        ret += olThursday;

    index = NULL;
    index = wcsstr(in, TEXT("FR"));
    if(index)
        ret += olFriday;

    index = NULL;
    index = wcsstr(in, TEXT("SA"));
    if(index)
        ret += olSaturday;

    return ret;
}

bool isDayOfWeek(wchar_t* string) {

    bool ret = false;
    wchar_t* weekDay[] = {TEXT("SU"), TEXT("MO"), TEXT("TU"), TEXT("WE"), TEXT("TH"), TEXT("FR"), TEXT("SA")};

    for(int i = 0; i < 7 ; i++)
        if(!wcscmp(string, weekDay[i]))
            return true;

    return ret;
}

long getWeekDay(DATE  dt) {
    long ret = 0;

    SYSTEMTIME st;
    VariantTimeToSystemTime(dt, &st);

    ret = (long)pow(2, st.wDayOfWeek);

    return ret;
}


BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
    DWORD pid = NULL;
    DWORD threadId = GetWindowThreadProcessId(hwnd, &pid);
    if (pid == (DWORD)lParam)
    {
        SendMessage(hwnd,WM_CLOSE, 0, 0);
    }

    return TRUE;
}


DWORD getProcessPid(const wchar_t *processName)
{
    PROCESSENTRY32 lppe;
    BOOL next = TRUE;
    HANDLE hProcess = 0;
    DWORD pid = 0;

    // try to see in the registry the pid if there is any
    DWORD pidFromRegistry = 0;
    wchar_t value[128];
    getClientConfigurationInternal(NULL, PROPERTY_SPDM_PID, value, FALSE);
    if (wcscmp(value, TEXT("")) != 0 && wcscmp(value, TEXT("0")) != 0) {
        pidFromRegistry = atol(_wcc(value));
        DWORD code = 0;
        HANDLE h = NULL;

        h = OpenProcess(0, FALSE, pidFromRegistry);

        if (h) {
            GetExitCodeProcess(h, &code);
            if (code != STILL_ACTIVE) {
                pidFromRegistry = 0;
            }
        }
    }

    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    // if there are any errors we return the value of the registry
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        return pidFromRegistry;
    }

    /*
    * Try to understand if there are the process...
    */
    lppe.dwSize = sizeof(PROCESSENTRY32);

    if (!Process32First(hSnapshot, &lppe))
        goto exit;

    if (wcsstr(lppe.szExeFile, processName) != NULL) {
        pid = lppe.th32ProcessID;
    }

    do {
        next = Process32Next(hSnapshot, &lppe);

        if (!next)
            break;

        if (wcsstr(lppe.szExeFile, processName) != NULL ) {
            pid = lppe.th32ProcessID;
            break;
        }

    } while(next);

exit:

    if (hSnapshot)
        CloseToolhelp32Snapshot(hSnapshot);
    CloseHandle(hProcess);

    if (pidFromRegistry != 0 && pid == 0) {
        pid = pidFromRegistry;
    }
    return pid;
}


DWORD stopProcess(DWORD pid)
{
    DWORD out = EnumWindows(&EnumWindowsProc, pid);

    return out;
}

DWORD stopProcessByName(const wchar_t *name)
{
    DWORD out = 0;
    DWORD pid = getProcessPid(name);
    out = stopProcess(pid);
    return out;
}

DWORD getMemoryAvailable() {
    MEMORYSTATUS mem;
    GlobalMemoryStatus(&mem);