obex.idl

来自「Windows CE 6.0 Server 源码」· IDL 代码 · 共 602 行 · 第 1/2 页

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft shared
// source or premium shared source license agreement under which you licensed
// this source code. If you did not accept the terms of the license agreement,
// you are not authorized to use this source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the SOURCE.RTF on your install media or the root of your tools installation.
// THE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES.
//
/*----------------------------------------------------------------------------
    obex.idl
        Interface definitions for OBEX

        This file will be processed by the MIDL tool to
        produce the type library (obex.tlb) and marshalling code.

    All rights reserved.
 ----------------------------------------------------------------------------*/

import "oaidl.idl";
import "ocidl.idl";

cpp_quote("#include <obexerr.h>")

#if defined(UNDER_CE) || defined(WINCE)
typedef IPropertyBag* LPPROPERTYBAG2;
#endif 

interface IDeviceEnum;
interface IPropertyBagEnum;
interface IObexService;
interface IObexDevice;
interface IHeaderCollection;
interface IHeaderEnum;
interface IObexServiceConnection;

const DWORD     OBEX_VERSION_10               = 0x10;

const DWORD     OBEX_VERSION                  = OBEX_VERSION_10;
const DWORD     INVALID_CONN_ID               = 0xffffffff;


const DWORD SEND_DEVICE_UPDATES                     = 0x01;

// 
// OBEX notifications
//
typedef enum _OBEX_EVENT
{
    OE_QUERY_PASSWORD,
    OE_NEW_CONNECTION,
    OE_NEW_COMMAND,
    OE_ABORT,
    OE_DISCONNECT,
	OE_DEVICE_ARRIVAL,
	OE_DEVICE_DEPARTURE,
	OE_DEVICE_UPDATE,
} OBEX_EVENT, * LPOBEX_EVENT;

//
// Inbox Sink events
//
typedef enum _INBOX_EVENT
{
    IE_MIME,
    IE_SYNC,
} INBOX_EVENT, * LPINBOX_EVENT;

typedef struct _INBOX_EVENT_DATA
{
    DWORD                       dwRequest;				// get or put
    DWORD                       dwInboxEvent;			// sync or mime event?
	LPCWSTR						pszName;				// mime type or name
	LPCWSTR						pszInboxDestination;	// where this should go
    IHeaderCollection *         pHeaderCol;				// headers from the request
    IStream *                   pStream;				// data
} INBOX_EVENT_DATA, * PINBOX_EVENT_DATA;


// 
// SetPath Flags
//
// Flag to backup one level before applying the setpath
const DWORD     SETPATH_FLAG_BACKUP            = 0x00000001;
// Flag to return an error instead of creating a new directory
const DWORD     SETPATH_FLAG_DONT_CREATE       = 0x00000002;

// 
// OBEX header support
//
// 0x30 to 0x3F are user definable
//
const DWORD     OBEX_HEADER_UNICODE            = 0x00;
const DWORD     OBEX_HEADER_STREAM             = 0x40;
const DWORD     OBEX_HEADER_1BYTE              = 0x80;
const DWORD     OBEX_HEADER_4BYTE              = 0xC0;

const DWORD     OBEX_HEADER_COUNT              = ( 0x00 | OBEX_HEADER_4BYTE   );
const DWORD     OBEX_HEADER_NAME               = ( 0x01 | OBEX_HEADER_UNICODE );
const DWORD     OBEX_HEADER_TYPE               = ( 0x02 | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_LENGTH             = ( 0x03 | OBEX_HEADER_4BYTE   );
const DWORD     OBEX_HEADER_TIME_ISO           = ( 0x04 | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_TIME_COMPAT        = ( 0x04 | OBEX_HEADER_4BYTE   );
const DWORD     OBEX_HEADER_DESCRIPTION        = ( 0x05 | OBEX_HEADER_UNICODE );
const DWORD     OBEX_HEADER_TARGET             = ( 0x06 | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_HTTP               = ( 0x07 | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_BODY               = ( 0x08 | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_END_OF_BODY        = ( 0x09 | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_WHO                = ( 0x0A | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_CONNECTION_ID      = ( 0x0B | OBEX_HEADER_4BYTE   );
const DWORD     OBEX_HEADER_APP_PARAMS         = ( 0x0C | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_AUTH_CHALLENGE     = ( 0x0D | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_AUTH_RESPONSE      = ( 0x0E | OBEX_HEADER_STREAM  );
const DWORD     OBEX_HEADER_OBJECT_CLASS       = ( 0x0F | OBEX_HEADER_STREAM  );

typedef struct _OBEX_HEADER
{
    byte        bId;    // id of the header from above

    [switch_is(bId & OBEX_HEADER_4BYTE)]
    union
    {   
        [case(OBEX_HEADER_UNICODE)]
            [string] LPWSTR pszData;
        
        [case(OBEX_HEADER_4BYTE)]
            DWORD       dwData;
    
        [case(OBEX_HEADER_1BYTE)]
            byte        bData;
        
        [case(OBEX_HEADER_STREAM)]
            struct
            {   
                DWORD   dwSize;     // size of the byte array
                [size_is(dwSize)] byte *  pbaData;
            } ba;

    } value;

} OBEX_HEADER;

typedef struct _OBEX_REQUEST
{
    DWORD                       dwRequest;
    DWORD                       dwFlags;
    IHeaderCollection *         pHeaderCol;
    BOOL                        fStream;
    IStream *                   pStream;
} OBEX_REQUEST, * POBEX_REQUEST;

// 
// OBEX command opcodes
//
// 0x06 to 0x0F are reserved
// 0x10 to 0x1F are user definable
//
const DWORD     OBEX_OPCODE_FINALBIT        = 0x80;
const DWORD     OBEX_OPCODE_CONNECT         = ( 0x00 | OBEX_OPCODE_FINALBIT );
const DWORD     OBEX_OPCODE_DISCONNECT      = ( 0x01 | OBEX_OPCODE_FINALBIT );
const DWORD     OBEX_OPCODE_PUT             = 0x02;
const DWORD     OBEX_OPCODE_GET             = 0x03;
const DWORD     OBEX_OPCODE_SET_PATH        = ( 0x05 | OBEX_OPCODE_FINALBIT );
const DWORD     OBEX_OPCODE_ABORT           = ( 0x7F | OBEX_OPCODE_FINALBIT );

//
// OBEX Response codes
//
// 0x00 to 0x0F are reserved
//
const DWORD     OBEX_REPLY_CONTINUE                             = 0x10; 
const DWORD     OBEX_REPLY_SUCCESS                              = 0x20;
const DWORD     OBEX_REPLY_CREATED                              = 0x21; 
const DWORD     OBEX_REPLY_ACCEPTED                             = 0x22; 
const DWORD     OBEX_REPLY_NON_AUTHORITATIVE_INFO               = 0x23; 
const DWORD     OBEX_REPLY_NO_CONTENT                           = 0x24; 
const DWORD     OBEX_REPLY_RESET_CONTENT                        = 0x25; 
const DWORD     OBEX_REPLY_PARTIAL_CONTENT                      = 0x26; 

const DWORD     OBEX_REPLY_MULIPLE_CHOICES                      = 0x30; 
const DWORD     OBEX_REPLY_MOVED_PERMANENTLY                    = 0x31;
const DWORD     OBEX_REPLY_MOVED_TEMPORARILY                    = 0x32; 
const DWORD     OBEX_REPLY_SEE_OTHER                            = 0x33; 
const DWORD     OBEX_REPLY_NOT_NODIFIED                         = 0x34; 
const DWORD     OBEX_REPLY_USE_PROXY                            = 0x35; 

const DWORD     OBEX_REPLY_FAIL_BAD_REQUEST                     = 0x40;
const DWORD     OBEX_REPLY_FAIL_UNAUTHORIZED                    = 0x41;
const DWORD     OBEX_REPLY_FAIL_PAYMENT_REQUIRED                = 0x42; 
const DWORD     OBEX_REPLY_FAIL_FORBIDDEN                       = 0x43; 
const DWORD     OBEX_REPLY_FAIL_NOT_FOUND                       = 0x44; 
const DWORD     OBEX_REPLY_FAIL_METHOD_NOT_ALLOWED              = 0x45; 
const DWORD     OBEX_REPLY_FAIL_NOT_ACCEPTABLE                  = 0x46; 
const DWORD     OBEX_REPLY_FAIL_PROXY_AUTHORIZATION_REQUIRED    = 0x47; 
const DWORD     OBEX_REPLY_FAIL_REQUEST_TIME_OUT                = 0x48; 
const DWORD     OBEX_REPLY_FAIL_CONFLICT                        = 0x49; 
const DWORD     OBEX_REPLY_FAIL_GONE                            = 0x4A;  
const DWORD     OBEX_REPLY_FAIL_LENGTH_REQUIRED                 = 0x4B; 
const DWORD     OBEX_REPLY_FAIL_PRECONDITION_FAILED             = 0x4C; 
const DWORD     OBEX_REPLY_FAIL_REQUESTED_ENTITY_TOO_LARGE      = 0x4D; 
const DWORD     OBEX_REPLY_FAIL_REQUEST_URL_TOO_LARGE           = 0x4E; 
const DWORD     OBEX_REPLY_FAIL_UNSUPPORTED_MEDIA_TYPE          = 0x4F; 

const DWORD     OBEX_REPLY_FAIL_INTERNAL_SERVER_ERROR           = 0x50; 
const DWORD     OBEX_REPLY_FAIL_NOT_IMPLEMENTED                 = 0x51; 
const DWORD     OBEX_REPLY_FAIL_BAD_GATEWAY                     = 0x52; 
const DWORD     OBEX_REPLY_FAIL_SERVICE_UNAVAILABLE             = 0x53; 
const DWORD     OBEX_REPLY_FAIL_GATEWAY_TIMEOUT                 = 0x54; 
const DWORD     OBEX_REPLY_FAIL_HTTP_VERSION_NOT_SUPPORTED      = 0x55; 

const DWORD     OBEX_REPLY_FAIL_DATABASE_FULL                   = 0x60;
const DWORD     OBEX_REPLY_FAIL_DATABASE_LOCKED                 = 0x61; 

//
// device capabilities
//
// The lower word is reserved, the upper word can be
// used for new capabilities.
//
const DWORD     OBEX_DEVICE_CAP_UNKNOWN         = 0x00000000;
const DWORD     OBEX_DEVICE_CAP_PUSH            = 0x00000001; // essentially the default inbox
const DWORD     OBEX_DEVICE_CAP_FILE_BROWSE     = 0x00000002; // File browser service
const DWORD     OBEX_DEVICE_CAP_SYNC            = 0x00000004; // IrMC Sync service

    [
        object,
        uuid(0C5A5B12-2979-42D1-9E15-A63E34383B58),
        helpstring("IObex Interface"),
        pointer_default(unique)
    ]
    interface IObex : IUnknown
    {
        [helpstring("method Initialize")] 
        HRESULT Initialize();
        
        [helpstring("method Shutdown")] 
        HRESULT Shutdown();
        
        [helpstring("EnumDevices returns the current list of known devices.")] 
        HRESULT EnumDevices([out] IDeviceEnum **ppDeviceEnum, [in] REFCLSID uuidTransport);
        
        [helpstring("method EnumTransports")] 
        HRESULT EnumTransports([out] IPropertyBagEnum **ppTransportEnum);
        
        [helpstring("method RegisterService")] 
        HRESULT RegisterService([in] IPropertyBag *pPropertyBag, [out] IObexService **ppService);

        [helpstring("Create a device object using the information passed in.")] 
        HRESULT BindToDevice([in] IPropertyBag *pPropertyBag, [out] IObexDevice **ppDevice);

        [helpstring("Start device enumeration.")] 
        HRESULT StartDeviceEnum();

        [helpstring("Stop device enumeration.")] 
        HRESULT StopDeviceEnum();
    };


    [object,
        uuid(8FF83D03-CD48-420a-83DD-52D39E8607E2),
        helpstring("IObex2 Interface"),
        pointer_default(unique)
    ]
    interface IObex2 : IObex
    {
        [helpstring("Pause device enumeration.")]
        HRESULT PauseDeviceEnum(BOOL fPauseOn);
    };
    
    [
        object,
        uuid(3ED60A15-6FB0-4A81-8ED3-49097A8E292C),
        helpstring("IObexDevice Interface"),
        pointer_default(unique)
    ]
    interface IObexDevice : IUnknown
    {
        [helpstring("Connect to this device")] 
        HRESULT Connect([in, string, unique] LPCWSTR pszPassword, [in] DWORD dwCapability, [in] IHeaderCollection * pHeaders);
        
        [helpstring("Disconnect from this device")] 
        HRESULT Disconnect([in] IHeaderCollection * pHeaders);
        
        [helpstring("Perform a get on this device")] 
        HRESULT Get([in] IHeaderCollection * pHeaders, [out] IStream **ppStream);

        [helpstring("perform a Put")] 
        HRESULT Put([in] IHeaderCollection * pHeaders, [in, out, unique] IStream **ppStream);
        
        [helpstring("method Abort")] 
        HRESULT Abort([in] IHeaderCollection * pHeaders);
        
        [helpstring("method SetPath")] 
        HRESULT SetPath([in] LPCWSTR pszName, [in] DWORD dwFlags, [in] IHeaderCollection * pHeaders);
        
        [helpstring("method EnumProperties")] 
        HRESULT EnumProperties([in] REFIID riid, [out, iid_is(riid)] void **ppv);