Task Scheduler

[JR]

Here is my first attempt at using COM with Aurora.

Save as mstask.inc

Code Select Expand


////////////////////////////////////////////////////////////////////////
// Task Scheduler interfaces
////////////////////////////////////////////////////////////////////////

#ifndef __mstask_inc__
#define __mstask_inc__

struct GUID,1
{
  unsigned int data1;
  unsigned word data2;
  unsigned word data3;
  unsigned byte data4[8];
}

/*
* struct SYSTEMTIME, 2
* {
*   unsigned word wYear;
*   unsigned word wMonth;
*   unsigned word wDayOfWeek;
*   unsigned word wDay;
*   unsigned word wHour;
*   unsigned word wMinute;
*   unsigned word wSecond;
*   unsigned word wMilliseconds;
}
*/

#define TASK_SUNDAY       0x1
#define TASK_MONDAY       0x2
#define TASK_TUESDAY      0x4
#define TASK_WEDNESDAY    0x8
#define TASK_THURSDAY     0x10
#define TASK_FRIDAY       0x20
#define TASK_SATURDAY     0x40
#define TASK_FIRST_WEEK   1
#define TASK_SECOND_WEEK  2
#define TASK_THIRD_WEEK   3
#define TASK_FOURTH_WEEK  4
#define TASK_LAST_WEEK    5
#define TASK_JANUARY      0x1
#define TASK_FEBRUARY     0x2
#define TASK_MARCH        0x4
#define TASK_APRIL        0x8
#define TASK_MAY          0x10
#define TASK_JUNE         0x20
#define TASK_JULY         0x40
#define TASK_AUGUST       0x80
#define TASK_SEPTEMBER    0x100
#define TASK_OCTOBER      0x200
#define TASK_NOVEMBER     0x400
#define TASK_DECEMBER     0x800
#define TASK_FLAG_INTERACTIVE                  0x1
#define TASK_FLAG_DELETE_WHEN_DONE             0x2
#define TASK_FLAG_DISABLED                     0x4
#define TASK_FLAG_START_ONLY_IF_IDLE           0x10
#define TASK_FLAG_KILL_ON_IDLE_END             0x20
#define TASK_FLAG_DONT_START_IF_ON_BATTERIES   0x40
#define TASK_FLAG_KILL_IF_GOING_ON_BATTERIES   0x80
#define TASK_FLAG_RUN_ONLY_IF_DOCKED           0x100
#define TASK_FLAG_HIDDEN                       0x200
#define TASK_FLAG_RUN_IF_CONNECTED_TO_INTERNET 0x400
#define TASK_FLAG_RESTART_ON_IDLE_RESUME       0x800
#define TASK_FLAG_SYSTEM_REQUIRED              0x1000
#define TASK_FLAG_RUN_ONLY_IF_LOGGED_ON        0x2000
#define TASK_TRIGGER_FLAG_HAS_END_DATE         0x1
#define TASK_TRIGGER_FLAG_KILL_AT_DURATION_END 0x2
#define TASK_TRIGGER_FLAG_DISABLED             0x4
#define TASK_MAX_RUN_TIMES     1440

// enum TASK_TRIGGER_TYPE
#typedef TASK_TRIGGER_TYPE unsigned int
#define TASK_TIME_TRIGGER_ONCE 0
#define TASK_TIME_TRIGGER_DAILY 1
#define TASK_TIME_TRIGGER_WEEKLY 2
#define TASK_TIME_TRIGGER_MONTHLY 3
#define TASK_TIME_TRIGGER_MONTHLYDOW 4
#define TASK_EVENT_TRIGGER_ON_IDLE 5
#define TASK_EVENT_TRIGGER_AT_SYSTEMSTART 6
#define TASK_EVENT_TRIGGER_AT_LOGON 7

struct DAILY
{
  unsigned word DaysInterval;
}

struct WEEKLY
{
  unsigned word WeeksInterval;
  unsigned word rgfDaysOfTheWeek;
}

struct MONTHLYDATE
{
  unsigned int rgfDays;
  unsigned word rgfMonths;
}

struct MONTHLYDOW
{
  unsigned word wWhichWeek;
  unsigned word rgfDaysOfTheWeek;
  unsigned word rgfMonths;
}

union TRIGGER_TYPE_UNION
{
  DAILY Daily;
  WEEKLY Weekly;
  MONTHLYDATE MonthlyDate;
  MONTHLYDOW MonthlyDOW;
}

struct TASK_TRIGGER
{
  unsigned word cbTriggerSize;
  unsigned word Reserved1;
  unsigned word wBeginYear;
  unsigned word wBeginMonth;
  unsigned word wBeginDay;
  unsigned word wEndYear;
  unsigned word wEndMonth;
  unsigned word wEndDay;
  unsigned word wStartHour;
  unsigned word wStartMinute;
  unsigned int MinutesDuration;
  unsigned int MinutesInterval;
  unsigned int rgFlags;
  TASK_TRIGGER_TYPE TriggerType;
  TRIGGER_TYPE_UNION Type;
  unsigned word Reserved2;
  unsigned word wRandomMinutesInterval;
}


interface IUnknown
{
    declare virtual QueryInterface(
        /* [in] REFIID */ GUID *riid,
        /* [iid_is][out] void __RPC_FAR *__RPC_FAR */ void *ppvObject), int;
    declare virtual AddRef(), unsigned int;
    declare virtual Release(), unsigned int;
}

// {148BD52B-A2AB-11CE-B11F-00AA00530503}
// DEFINE_GUID(IID_ITaskTrigger, 0x148BD52BL, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03);
interface ITaskTrigger : IUnknown
{
    declare virtual SetTrigger(
        /* [in] const PTASK_TRIGGER */ TASK_TRIGGER *pTrigger), int;
    declare virtual GetTrigger(
        /* [out] const PTASK_TRIGGER */ TASK_TRIGGER *pTrigger), int;
    declare virtual GetTriggerString(
        /* [out] LPWSTR __RPC_FAR */ unsigned word *ppwszTrigger), int;
}

// {a6b952f0-a4b1-11d0-997d-00aa006887ec}
// DEFINE_GUID(IID_IScheduledWorkItem, 0xa6b952f0L, 0xa4b1, 0x11d0, 0x99, 0x7d, 0x00, 0xaa, 0x00, 0x68, 0x87, 0xec);
interface IScheduledWorkItem : IUnknown
{
    declare virtual CreateTrigger(
        /* [out] WORD __RPC_FAR */ unsigned word *piNewTrigger,
        /* [out] ITaskTrigger __RPC_FAR *__RPC_FAR */ ITaskTrigger *ppTrigger), int;
    declare virtual DeleteTrigger(
        /* [in] WORD */ unsigned word iTrigger), int;
    declare virtual GetTriggerCount(
        /* [out] WORD __RPC_FAR */ unsigned word *pwCount), int;
    declare virtual GetTrigger(
        /* [in] WORD */ unsigned word iTrigger,
        /* [out] ITaskTrigger __RPC_FAR *__RPC_FAR */ ITaskTrigger *ppTrigger), int;
    declare virtual GetTriggerString(
        /* [in] WORD */ unsigned word iTrigger,
        /* [out] LPWSTR __RPC_FAR */ unsigned word *ppwszTrigger), int;
    declare virtual GetRunTimes(
        /* [in] const LPSYSTEMTIME */ SYSTEMTIME *pstBegin,
        /* [in] const LPSYSTEMTIME */ SYSTEMTIME *pstEnd,
        /* [out][in] WORD __RPC_FAR */ unsigned word *pCount,
        /* [out] LPSYSTEMTIME __RPC_FAR */ SYSTEMTIME *rgstTaskTimes), int;
    declare virtual GetNextRunTime(
        /* [out][in] SYSTEMTIME __RPC_FAR */ SYSTEMTIME *pstNextRun), int;
    declare virtual SetIdleWait(
        /* [in] WORD */ unsigned word wIdleMinutes,
        /* [in] WORD */ unsigned word wDeadlineMinutes), int;
    declare virtual GetIdleWait(
        /* [in] WORD __RPC_FAR */ unsigned word *pwIdleMinutes,
        /* [in] WORD __RPC_FAR */ unsigned word *pwDeadlineMinutes), int;
    declare virtual Run(), int;
    declare virtual Terminate(), int;
    declare virtual EditWorkItem(
        /* [in] HWND */ unsigned int hParent,
        /* [in] DWORD */ unsigned int dwReserved), int;
    declare virtual GetMostRecentRunTime(
        /* [out] SYSTEMTIME __RPC_FAR */ SYSTEMTIME *pstLastRun), int;
    declare virtual GetStatus(
        /* [out] int __RPC_FAR */ int *phrStatus), int;
    declare virtual GetExitCode(
        /* [out] DWORD __RPC_FAR */ unsigned int *pdwExitCode), int;
    declare virtual SetComment(
        /* [in] LPCWSTR */ unsigned word *pwszComment), int;
    declare virtual GetComment(
        /* [out] LPCWSTR __RPC_FAR */ unsigned word *ppwszComment), int;
    declare virtual SetCreator(
        /* [in] LPCWSTR */ unsigned word *pwszCreator), int;
    declare virtual GetCreator(
        /* [out] LPCWSTR __RPC_FAR */ unsigned word *ppwszCreator), int;
    declare virtual SetWorkItemData(
        /* [in] WORD */ unsigned word cbData,
        /* [in] BYTE __RPC_FAR rgbData[  ] */ unsigned byte *rgbData), int;
    declare virtual GetWorkItemData(
        /* [out] WORD __RPC_FAR */ unsigned word *pcbData,
        /* [out] BYTE __RPC_FAR *__RPC_FAR */ unsigned byte *prgbData), int;
    declare virtual SetErrorRetryCount(
        /* [in] WORD */ unsigned word wRetryCount), int;
    declare virtual GetErrorRetryCount(
        /* [out] WORD __RPC_FAR */ unsigned word *pwRetryCount), int;
    declare virtual SetErrorRetryInterval(
        /* [in] WORD */ unsigned word wRetryInterval), int;
    declare virtual GetErrorRetryInterval(
        /* [out] WORD __RPC_FAR */ unsigned word *pwRetryInterval), int;
    declare virtual SetFlags(
        /* [in] DWORD */ unsigned int dwFlags), int;
    declare virtual GetFlags(
        /* [out] DWORD __RPC_FAR */ unsigned int *pdwFlags), int;
    declare virtual SetAccountInformation(
        /* [in] LPCWSTR */ unsigned word *pwszAccountName,
        /* [in] LPCWSTR */ unsigned word *pwszPassword), int;
    declare virtual GetAccountInformation(
        /* [out] LPWSTR __RPC_FAR */ unsigned word *ppwszAccountName), int;
}


// {148BD524-A2AB-11CE-B11F-00AA00530503}
// DEFINE_GUID(IID_ITask, 0x148BD524L, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03);
interface ITask : IScheduledWorkItem
{
    declare virtual SetApplicationName(
        /* [in] LPCWSTR */ unsigned word *pwszApplicationName), int;
    declare virtual GetApplicationName(
        /* [out] LPWSTR __RPC_FAR */ unsigned word *ppwszApplicationName), int;
    declare virtual SetParameters(
        /* [in] LPCWSTR */ unsigned word *pwszParameters), int;
    declare virtual GetParameters(
        /* [out] LPWSTR __RPC_FAR */ unsigned word *ppwszParameters), int;
    declare virtual SetWorkingDirectory(
        /* [in] LPCWSTR */ unsigned word *pwszWorkingDirectory), int;
    declare virtual GetWorkingDirectory(
        /* [out] LPWSTR __RPC_FAR */ unsigned word *ppwszWorkingDirectory), int;
    declare virtual SetPriority(
        /* [in] DWORD */ unsigned int dwPriority), int;
    declare virtual GetPriority(
        /* [out] DWORD __RPC_FAR */ unsigned int *pdwPriority), int;
    declare virtual SetTaskFlags(
        /* [in] DWORD */ unsigned int dwFlags), int;
    declare virtual GetPriority(
        /* [out] DWORD __RPC_FAR */ unsigned int *pdwFlags), int;
    declare virtual SetMaxRunTime(
        /* [in] DWORD */ unsigned int dwMaxRunTimeMS), int;
    declare virtual GetMaxRunTime(
        /* [out] DWORD __RPC_FAR */ unsigned int *pdwMaxRunTimeMS), int;
}


// {148BD528-A2AB-11CE-B11F-00AA00530503}
// DEFINE_GUID(IID_IEnumWorkItems, 0x148BD528L, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03);
interface IEnumWorkItems : IUnknown
{
    declare virtual Next(
        /* [in] ULONG */ unsigned int celt,
        /* [out] LPWSTR __RPC_FAR *__RPC_FAR */ unsigned word *rgpwszNames,
        /* [out] ULONG __RPC_FAR */ unsigned word *pceltFetched), int;
    declare virtual Skip(
        /* [in] ULONG */ unsigned word celt), int;
    declare virtual Reset(), int;
    declare virtual Clone(
        /* [out] IEnumWorkItems __RPC_FAR *__RPC_FAR */ IEnumWorkItems *ppEnumWorkItems), int;
}


// {148BD527-A2AB-11CE-B11F-00AA00530503}
// DEFINE_GUID(IID_ITaskScheduler, 0x148BD527L, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03);
interface ITaskScheduler : IUnknown
{
    declare virtual SetTargetComputer(
        /* [in] LPCWSTR */ unsigned word *pwszComputer), int;
    declare virtual GetTargetComputer(
        /* [out] LPCWSTR __RPC_FAR */ unsigned word *ppwszComputer), int;
    declare virtual Enum(
        /* [out] IEnumWorkItems __RPC_FAR *__RPC_FAR */ IEnumWorkItems *ppEnumWorkItems), int;
    declare virtual Activate(
        /* [in] LPCWSTR */ unsigned word *pwszName,
        /* [in] REFIID */ GUID *riid,
        /* [out] IUnknown __RPC_FAR *__RPC_FAR */ IUnknown *ppUnk), int;
    declare virtual Delete_(
        /* [in] LPCWSTR */ unsigned word *pwszName), int;
    declare virtual NewWorkItem(
        /* [in] LPCWSTR */ unsigned word *pwszTaskName,
        /* [in] REFCLSID */ GUID *rclsid,
        /* [in] REFIID */ GUID *riid,
        /* [out] IUnknown __RPC_FAR *__RPC_FAR */ IUnknown *ppUnk), int;
    declare virtual AddWorkItem(
        /* [in] LPCWSTR */ unsigned word *pwszTaskName,
        /* [in] IScheduledWorkItem __RPC_FAR */ IScheduledWorkItem *pWorkItem), int;
    declare virtual IsOfType(
        /* [in] LPCWSTR */ unsigned word *pwszName,
        /* [in] REFIID */ GUID *riid), int;
}

// {148BD520-A2AB-11CE-B11F-00AA00530503}
// DEFINE_GUID(CLSID_CTask, 0x148BD520, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03);

// {148BD52A-A2AB-11CE-B11F-00AA00530503}
// DEFINE_GUID(CLSID_CTaskScheduler, 0x148BD52A, 0xA2AB, 0x11CE, 0xB1, 0x1F, 0x00, 0xAA, 0x00, 0x53, 0x05, 0x03);

// enum TASKPAGE
#typedef TASKPAGE unsigned int
#define TASKPAGE_TASK 0
#define TASKPAGE_SCHEDULE 1
#define TASKPAGE_SETTINGS 2

// {4086658a-cbbb-11cf-b604-00c04fd8d565}
// DEFINE_GUID(IID_IProvideTaskPage, 0x4086658aL, 0xcbbb, 0x11cf, 0xb6, 0x04, 0x00, 0xc0, 0x4f, 0xd8, 0xd5, 0x65);

interface IProvideTaskPage : IUnknown
{
    declare virtual GetPage(
        /* [in] TASKPAGE */ TASKPAGE *tpType,
        /* [in] BOOL */ int fPersistChanges,
        /* [out] HPROPSHEETPAGE __RPC_FAR */ unsigned int *phPage), int;
}

// #define ISchedulingAgent       ITaskScheduler
// #define IEnumTasks             IEnumWorkItems
// #define IID_ISchedulingAgent   IID_ITaskScheduler
// #define CLSID_CSchedulingAgent CLSID_CTaskScheduler

#endif


Sample code that uses the above include file:

Code Select Expand


////////////////////////////////////////////////////////////////////////
// This example enumerates all the tasks in the Scheduled Tasks folder
// of the local computer and prints the name of each task on the screen.
////////////////////////////////////////////////////////////////////////

/*
Compile this program to run in a console window.
*/

#include "mstask.inc"

import void CoTaskMemFree(void *pv);
import int CLSIDFromString(unsigned word *lpsz, GUID *pclsid);

import int MultiByteToWideChar(
  unsigned int CodePage,            // code page
  unsigned int dwFlags,             // character-type options
  unsigned byte *lpMultiByteStr,    // string to map
  int cbMultiByte,                  // number of bytes in string
  unsigned word *lpWideCharStr,     // wide-character buffer
  int cchWideChar                   // size of buffer
);

import int WideCharToMultiByte(
  unsigned int CodePage,            // code page
  unsigned int dwFlags,             // performance and mapping flags
  unsigned word *lpWideCharStr,     // wide-character string
  int cchWideChar,                  // number of chars in string.
  unsigned byte *lpMultiByteStr,    // buffer for new string
  int cbMultiByte,                  // size of buffer
  unsigned byte *lpDefaultChar,     // default for unmappable chars
  unsigned int *lpUsedDefaultChar   // set when default char used
);

import void RtlZeroMemory(void *Destination, unsigned int Length);
import int CoInitialize(void *pvReserved);
import void CoUninitialize();
import int CoCreateInstance(GUID *rclsid, pointer pUnkOuter, unsigned int dwClsContext, GUID *riid, void *ppv);

sub WINAPI_CLSIDFromString(string psz), GUID
{
    int hr;
    GUID rclsid;
    int nLen;
    pointer pwcs;

    nLen = (len(psz) + 1) * 2;
    pwcs = AllocHeap(nLen);
    RtlZeroMemory(pwcs, nLen);
    hr = MultiByteToWideChar(0, 0, psz, len(psz), pwcs, nLen);
    hr = CLSIDFromString(pwcs, rclsid);
    FreeHeap(pwcs);
    return rclsid;
}

CONST CLSCTX_INPROC_SERVER = 1;


////////////////////////////////////////////////////////////////////////
// main
////////////////////////////////////////////////////////////////////////

global sub main()
{
    int hr = 0;
    GUID CLSID_CTaskScheduler;
    GUID IID_ITaskScheduler;
    ITaskScheduler *pITS;

    CLSID_CTaskScheduler = WINAPI_CLSIDFromString("{148BD52A-A2AB-11CE-B11F-00AA00530503}");
    IID_ITaskScheduler = WINAPI_CLSIDFromString("{148BD527-A2AB-11CE-B11F-00AA00530503}");

    /////////////////////////////////////////////////////////////////
    // Call CoInitialize to initialize the COM library and
    // then call CoCreateInstance to get the Task Scheduler object.
    /////////////////////////////////////////////////////////////////

    hr = CoInitialize(NULL);
    if (hr = 0)
    {
        hr = CoCreateInstance(CLSID_CTaskScheduler,
                              NULL,
                              CLSCTX_INPROC_SERVER,
                              IID_ITaskScheduler,
                              &pITS);
        if (hr != 0)
        {
            CoUninitialize();
            return hr;
        }
    }
    else
    {
        return hr;
    }


    /////////////////////////////////////////////////////////////////
    // Call ITaskScheduler::Enum to get an enumeration object.
    /////////////////////////////////////////////////////////////////

    IEnumWorkItems *pIEnum;
    hr = pITS->Enum(&pIEnum);
    pITS->Release();
    if (hr != 0)
    {
        CoUninitialize();
        return hr;
    }

    /////////////////////////////////////////////////////////////////
    // Call IEnumWorkItems::Next to retrieve tasks. Note that
    // this example tries to retrieve five tasks for each call.
    /////////////////////////////////////////////////////////////////

    unsigned int TASKS_TO_RETRIEVE;
    unsigned word *rgpwszNames;
    unsigned int dwFetchedTasks = 0;
    int nLen = 0;
    int count = 0;
    dstring psz[260];

    TASKS_TO_RETRIEVE = 5;
    do
    {
        hr = pIEnum->Next(TASKS_TO_RETRIEVE, &rgpwszNames, &dwFetchedTasks);
        if (dwFetchedTasks > 0)
        {
            ///////////////////////////////////////////////////////////////
            // Process each task. Note that this example prints the
            // name of each task to the screen.
            //////////////////////////////////////////////////////////////
            for(count = 0; count < dwFetchedTasks; count = count + 1)
            {
                nLen = WideCharToMultiByte(0, 0, *(pointer)rgpwszNames[count], -1, psz, 260, 0, 0);
                print(psz);
                CoTaskMemFree(*(pointer)rgpwszNames[count]);
            }
            CoTaskMemFree(rgpwszNames);
        }
    } until (dwFetchedTasks = 0);
    pIEnum->Release();

    CoUninitialize();

    do{}until getkey() <> "";
    return;
}


[Ionic Wind Support Team]

Jose,
You can use the attachment feature of the forum to directly attach a .src or .inc file too.

Just click on "Additional Options" when making the post

Paul.

[JR]

Done. I didn't know how to do it. Many thanks.

[pistol350]

Just a Tips for people wanting to use this code from Jose Roca.

Using the source code as is with recent versions of the compiler will surely give a synthax error due to the enum declaration. Indeed ,In updated compilers "enum" is an integrated function of the compiler.
So,don't forget to change the lines containing "enum" to "enum1" for instance.

Cheers!