KR20050039665A

KR20050039665A - 애플리케이션에 상태 변경을 통지하기 위한 방법 및 시스템

Info

Publication number: KR20050039665A
Application number: KR1020040084927A
Authority: KR
Inventors: 아미가오리엠.; 아락아단; 크로스브라이언; 카라챌잔; 플러재이슨윌리암; 레이비로버트; 코치제이크
Original assignee: 마이크로소프트 코포레이션
Priority date: 2003-10-23
Filing date: 2004-10-22
Publication date: 2005-04-29
Also published as: KR100920850B1; US20050091219A1; US20150150027A1; CN102291446A; US8990695B2; CN1617501B; US20100077310A1; US7644376B2; EP1679596A2; CN1617501A; US10169111B2; JP4790245B2; EP1679596A3; JP2005129067A; CN102291446B

Abstract

장치, 애플리케이션, 서비스 상태, 및 풍부한 통지 중개 아키텍처를 저장하는 통합된 메카니즘을 위한 방법 및 시스템을 기술한다. 클라이언트는 통지 중개자에 상태 속성의 변경에 대한 통지를 수신하는 것을 등록한다. 등록된 상태 속성이 변경될 때, 통지 중개자는 상태 변경을 통지받을 클라이언트를 결정하고 그 클라이언트에게 변경에 관한 통지를 제공한다. 상태 변경이 소정의 조건을 만족할 때, 또는 스케줄에 기반하여, 클라이언트는 상태가 변경될 때마다 통지될 수 있다. 애플리케이션은 상태 변경에 응답하여 런칭(launch)될 수도 있다. 제공되는 API는 장치 내의 다른 컴포넌트들을 통한 상태 변경 정보 액세스의 통합된 방법을 제공한다.

Description

애플리케이션에 상태 변경을 통지하기 위한 방법 및 시스템{FLEXIBLE ARCHITECTURE FOR NOTIFYING APPLICATIONS OF STATE CHANGES}

본 특허 출원은 2003년 10월 23일에 출원된 미국 가특허출원 번호 60/513,723의 35 미국 코드 §119(e) 하의 권리를 주장한다.

오늘날, 모바일 장치는 다양한 애플리케이션을 실행시키고 사용자가 현재의 새로운 정보를 지속적으로 가질 수 있도록 설계된다. 몇몇의 이들 장치는 PDA(personal digital assistant), 무선 전화, 및 이메일 장치를 포함한다. 모바일 장치는 현재 다양한 수단을 통하여 인터넷 및 다른 네트워크에 접속할 수 있고 그러므로 네트워크를 통하여 정보를 교환할 수 있다. 이들 모바일 장치는 애플리케이션을 업데이트하고 이메일, 이메일의 첨부물, 및 웹 페이지 컨텐츠와 같은, 정보를 송신하고 수신할 수 있다. 이 모든 기능을 제공하는 것은 새로운 이메일이 사용가능할 때, 장치의 스크린이 활성화되었을 때, 전화 호출을 수신할 때, 등과 같은, 다양한 이벤트가 모바일 장치 상의 애플리케이션에 통지되는 것이 요구된다. 그러나, 장치와 연관된 모든 다른 상태 변경을 액세스하는 것은 어려운 일이다.

간단히 기술하자면, 본 발명은 장치들 간에서의 상태(state) 및 통지 아키텍쳐의 통합에 관한 것이다.

본 발명의 일면에 따르면, 클라이언트는 통지 중개자에 상태 속성의 변경에 대한 통지를 수신하는 것을 등록한다. 등록된 상태 속성이 변경되면, 통지 중개자는 상태 변경을 통지받을 클라이언트를 결정하고 그 클라이언트에게 변경에 관련된 통지를 제공한다. 예를 들면, 클라이언트는 배터리 전력, 네트워크 접속, 메모리 사용량, 등의 변경에 관련된 통지를 수신하는 것을 등록할 수 있다. 이들 등록된 상태 속성 중 하나가 변경될 때마다, 통지 중개자는 클라이언트에게 통지 메세지를 송신한다.

본 발명의 다른 양상에 따르면, 상태 변경이 소정의 조건을 충족시킬 때에 혹은, 스케줄에 기반하여, 상태가 변경될 때마다 클라이언트는 통지받을 수 있다.

본 발명의 또 다른 양상에 따라서, 애플리케이션은 상태 변경 또는 스케줄에 응답하여 런칭될 수 있다. 예를 들면, 모바일 장치가 애플리케이션이 런칭되도록 지시하는 메세지를 수신하는 등의, 특정 이벤트가 발생할 때 클라이언트는 애플리케이션이 시동되게 하는 것을 등록할 수 있다. 애플리케이션은 또한 클라이언트가 구성한 스케줄에 기반하여 시동될 수도 있다.

본 발명의 또 다른 양상에 따르면, 장치 내의 다른 컴포넌트들을 통한 상태 변경 정보 액세스의 통합된 방법을 제공하는 것에 관한 애플리케이션 프로그래밍 인터페이스(API)가 제공된다. 예를 들면, 애플리케이션은 동일한 함수 호출을 사용하여 장치 내의 다른 컴포넌트들에 의하여 설정되는 상태 속성들을 액세스할 수 있다.

본 발명의 또 다른 양상에 따르면, 등록된 상태 속성들은 장치의 매 부팅마다 영속적일 수 있다.

간단히 기술하자면, 본 발명은 저장 장치, 애플리케이션, 서비스 상태, 및 풍부한 통지 중개 아키텍처를 위한 통합된 메카니즘의 방법 및 시스템 제공에 관한 것이다. 통상적으로는 클라이언트는 통지 중개자에 특정 상태 속성이 변경될 때 통지를 수신하는 것을 등록한다. 등록된 상태 속성이 변경될 때, 통지 중개자는 상태 변경을 통지 받을 클라이언트를 결정하고 그 클라이언트에게 변경에 관한 통지를 제공한다. 상태 변경이 소정의 조건을 만족할 때 또는, 스케줄에 기반하여, 클라이언트는 상태가 변경될 때마다 통지받을 수 있다. 애플리케이션은 상태 변경 또는 스케줄에 응답하여 런칭될 수도 있다. 장치 내의 다른 컴포넌트들을 통한 상태 변경 정보 액세스의 통합된 방법을 제공하는 것에 관한 애플리케이션 프로그래밍 인터페이스(API)가 또한 제공된다.

본 명세서 및 특허 청구 범위 전반에서, 이하의 용어들은 그 문맥이 그렇지 않다고 명확하게 상술하지 않는 한, 적어도 본 명세서에 명백하게 관련된 의미들을 취한다. 이하에 식별되는 의미들은 용어를 제한한다고 의도하지 않으며, 단지 그 용어의 예시적인 예들을 제공한다. "한", "하나", 및 "그"의 의미는 복수의 참조를 포함하고, "내에"의 의미는 "내에" 및 "상에"를 포함한다.

"상태 속성"이라는 용어는 보유 및 변경 통지를 위한 통지 시스템에 등록되고 저장되는 "상태" 변수를 칭한다.

"통지 요청"이란 용어는 상태 변경을 통지 받을 클라이언트로부터의 요청을 칭한다.

"통지 리스트"라는 용어는 상태 속성 변경 통지에 등록된 클라이언트의 목록을 칭한다.

"통지 중개자"라는 용어는 데이터 저장 장치로부터 데이터를 추가하고, 갱신하고, 제거하는 역할을 하는 기본적인 드라이버를 칭한다.

"상태 변경 컴포넌트"라는 용어는 데이터 저장 장치에서 상태 속성을 추가하고 갱신하거나 일반적으로 보유하는 임의의 컴포넌트를 칭한다.

"클라이언트"라는 용어는 상태 속성 변경 통지에 등록하는 임의의 컴포넌트를 칭한다. 클라이언트는 상태 변경 컴포넌트일 수 있고, 상태 변경 컴포넌트도 클라이언트일 수 있다.

"상태 속성 식별자"라는 용어는 상태 속성의 "사용자 친화적인" 스트링(이름) 표현을 칭한다. 이 식별자는 계층구조일 수 있으며 고유하다.

"조건적 통지"라는 용어는 상태 속성이 변경되고 상태 속성의 새로운 값이 통지 요청에 지정된 조건을 만족할 때 송신되는 통지를 칭한다.

예시적인 동작 환경

도 1을 참조하면, 본 발명을 구현하는 예시적인 시스템은 컴퓨팅 장치(100)와 같은, 컴퓨팅 장치를 포함한다. 컴퓨팅 장치(100)는 클라이언트 또는 서버로 구성될 수 있다. 매우 기본적인 구성에서, 컴퓨팅 장치(100)는 통상적으로 적어도 하나의 프로세싱 유닛(102) 및 시스템 메모리(104)를 포함한다. 컴퓨팅 장치의 정확한 구성 및 유형에 따라서, 시스템 메모리(104)는 (RAM과 같은) 휘발성, (ROM, 플래쉬 메모리, 등과 같은) 비휘발성 또는 이 둘의 몇몇의 조합일 수 있다. 시스템 메모리(104)는 통상적으로 오퍼레이팅 시스템(105), 하나 이상의 프로그램 모듈(106)을 포함하고, 프로그램 데이터(107)를 포함할 수 있다. 이 기본적인 구성은 점선(108) 내의 이들 컴포넌트로 도 1에 도시된다.

컴퓨팅 장치(100)는 추가적인 특징 또는 기능을 가질 수 있다. 예를 들면, 컴퓨팅 장치(100)는 예를 들면, 자기 디스크, 광디스크 또는 테이프와 같은 (분리형 및/또는 비분리형인) 추가적인 데이터 저장 장치 또한 포함할 수 있다. 이러한 추가적인 저장 장치는 분리형 저장 장치(109) 및 비분리형 저장 장치(110)로 도 1에 도시된다. 컴퓨터 저장 매체는 컴퓨터 판독가능 명령어, 데이터 구조, 프로그램 모듈, 또는 다른 데이터와 같은 정보의 저장을 위한 임의의 방법 또는 기술로 구현된 휘발성 및 비휘발성, 분리형 및 비분리형 매체를 포함할 수 있다. 시스템 메모리(104), 분리형 저장 장치(109) 및 비분리형 저장 장치(110)는 컴퓨터 저장 매체의 모든 예이다. 컴퓨터 저장 매체는 RAM, ROM, EEPROM, 플래쉬 메모리 또는 다른 메모리 기술, CD-ROM, DVD 또는 다른 광학 저장 장치, 자기 카세트, 자기 테이프, 자기 디스크 저장 장치 또는 다른 자기 저장 장치, 또는 원하는 정보를 저장하는 데에 이용될 수 있고 컴퓨팅 장치(100)에 의해 액세스 될 수 있는 임의의 기타 매체를 포함하지만, 이에 한정되지 않는다. 임의의 이러한 컴퓨터 저장 매체는 장치(100)의 일부일 수 있다. 컴퓨팅 장치(100)는 키보드, 마우스, 펜, 음성 입력 장치, 접촉 입력 장치, 등과 같은 입력 장치(들)(112)을 구비할 수 있다. 디스플레이, 스피커, 프린터, 등의 출력 장치(들)(114) 또한 포함될 수 있다.

컴퓨팅 장치(100)는 네트워크 등을 통해, 장치를 다른 컴퓨팅 장치들(118)과 통신하게 하는 통신 접속(116) 또한 포함한다. 통신 접속(116)은 통신 매체의 일례이다. 통신 매체는 통상적으로 컴퓨터 판독가능 명령어, 데이터 구조, 프로그램 모듈, 또는 반송파 또는 기타 전송 메카니즘 등의 변조된 데이터 신호 내의 다른 데이터에 의해 실시될 수 있으며, 임의의 정보 전달 매체를 포함한다. "변조된 데이터 신호"라는 용어는 신호 내에 정보를 인코딩하도록 설정되거나 변환된 특성을 하나 또는 그 이상을 갖는 신호를 의미한다. 예로서, 통신 매체는 유선 네트워크 또는 직접 유선 접속 등의 유선 매체와, 음향, RF, 적외선 및 기타 무선 매체 등의 무선 매체를 포함하지만, 이에 한정되지 않는다. 본 명세서에서 사용된 컴퓨터 판독가능 매체라는 용어는 저장 매체 및 통신 매체 둘다를 포함한다.

도 2를 참조하면, 본 발명을 구현하는 한 예시적인 시스템은 모바일 장치(200)와 같은, 모바일 장치를 포함한다. 모바일 장치(200)는 프로세서(260), 메모리(262), 디스플레이(228), 및 키패드(232)를 구비한다. 메모리(262)는 일반적으로 휘발성 메모리(예를 들면, RAM) 및 비휘발성 메모리(예를 들면, ROM, 플래쉬 메모리 등)를 둘다 포함한다. 모바일 장치(200)는 메모리(262)에 상주하고 프로세서(260)에서 실행하는, 마이크로소프트사의 윈도우즈 CE 오퍼레이팅 시스템 또는 다른 오퍼레이팅 시스템과 같은, 오퍼레이팅 시스템(264)을 포함한다. 키패드(232)는 (통상적인 전화에서) 누름 단추 숫자 다이얼 패드, (통상의 키보드와 같은) 다중-키 키보드일 수 있다. 디스플레이(228)는 액정 디스플레이, 또는 모바일 장치에 일반적으로 사용되는 임의의 다른 유형의 디스플레이일 수 있다. 디스플레이(228)는 접촉식일 수 있어서, 입력 장치와 같이도 동작할 수 있다.

하나 이상의 애플리케이션 프로그램(266)은 메모리(262)에 로딩되고 오퍼레이팅 시스템(264) 상에 실행된다. 애플리케이션 프로그램의 예는 전화 다이얼러 프로그램(phone dialer program), 이메일 프로그램, 스케줄링 프로그램, PIM(personal information management) 프로그램, 워드 프로세싱 프로그램, 스프레드시트(spreadsheet) 프로그램, 인터넷 브라우저 프로그램, 등을 포함한다. 애플리케이션 프로그램(266)은 장치와 관련된 상태 속성들에서 행위를 수행하는 데에 일반 API를 사용할 수 있다. 예를 들면, 전화 다이얼러 프로그램은 통지 시스템으로 신호 강도, 전화 상태, 배터리 전력, 등의 변화에 관련된 통지를 수신하는 것을 등록할 수 있다. 모바일 컴퓨팅 장치(200)는 또한 메모리(262) 내에 비휘발성 저장 장치(268)를 포함한다. 비휘발성 저장 장치(268)는 모바일 컴퓨팅 장치(200)가 전원이 나가도 상실되지 않는 영속적인 정보를 저장하는 데에 사용될 수 있다. 애플리케이션(266)은 이 저장 장치(268)에서 이메일 애플리케이션에 의해 사용되는 이메일 또는 다른 메세지와 같은 정보를 사용하고 저장하며, PIM에 의해 사용되는 정보, 스케줄링 프로그램에 의해 사용되는 약속 정보, 워드 프로세싱 프로그램에 의해 사용되는 문서 등에 접촉할 수 있다.

모바일 컴퓨팅 시스템(200)은 하나 이상의 배터리로 구현될 수 있는 전력 공급기(270)를 구비한다. 전력 공급기(270)는 배터리를 보충하거나 재충전하는 AC 어댑터 또는 전력 도킹 크래들(powered docking cradle)과 같은 외장형 전력 소스를 더 포함할 수 있다.

모바일 컴퓨팅 장치(200)는 또한 (도시되지 않은) LED 및 오디오 인터페이스(274)와 같은 외장형 통지 메카니즘도 포함할 수 있다. 이들 장치는 전력 공급기(270)에 직접적으로 연결될 수 있어서, 프로세서(260) 및 다른 컴포넌트가 배터리 전력을 보호하기 위해 전원을 내릴지라도 이들 장치는 활성화될 때에는 통지 메카니즘에 의해 지시된 기간동안 존속한다. 오디오 인터페이스(274)는 사용자에게 가청 신호를 제공하고 사용자로부터 가청 신호를 수신하는 데에 이용된다. 예를 들면, 오디오 인터페이스(274)는 전화 대화를 용이하게 하는 등을 위해, 가청 출력을 제공하는 스피커 및 가청 입력을 수신하는 마이크로폰에 연결될 수 있다.

모바일 컴퓨터 장치(200)는 이 장치가 무선 네트워크를 통해 다른 컴퓨팅 장치와 통신하게 하는 특정 통신 접속(240) 또한 포함할 수 있다. 모바일 컴퓨팅 장치(200)는 라디오 주파수 통신을 전송하고 수신하는 기능을 수행하는 라디오 인터페이스 계층(272) 또한 포함한다. 라디오 인터페이스 계층(272)은 통신 반송파 또는 서비스 제공자를 통하여, 모바일 컴퓨팅 장치(200)와 외부 세계 간의 무선 접속을 용이하게 한다. 라디오 인터페이스 계층(272)으로부터 및 그 계층으로의 전송은 오퍼레이팅 시스템(264)의 제어 하에 수행된다. 다시 말하면, 라디오 인터페이스 계층(272)에 의해 수신된 통신 및 통신 접속(240)은 오퍼레이팅 시스템(264) 등을 통해 애플리케이션 프로그램(266)으로 분산될 수 있다.

예시적인 상태 변경 통지 시스템

도 3은 본 발명의 양상에 따라, 예시적인 상태 관리 및 통지 시스템을 도시한다. 통지 시스템(300)은 상태 변경 컴포넌트(310), 클라이언트(315 및 320), 통지 중개자(335), 및 데이터 저장 장치(330)를 포함한다. 일 실시예에 따라서, 통지 중개자(335)는 또한 통지 리스트(340), 캐쉬된 속성(345) 및 스케줄러(350)를 보유한다.

클라이언트(315 또는 320)와 같은, 클라이언트는 통지 중개자(335)에 상태 속성의 변경에 관한 통지를 수신하는 것을 등록한다. 일반적으로, 클라이언트는 조건문을 만족시킬 때 또는, 스케줄에 기반하여, 상태 속성이 변경될 때마다 클라이언트가 통지를 수신하도록 등록시키는 통지 중개자(335)에 통지 요청을 생성할 수 있다. 통지는 영속적인 통지거나 일시적인 통지일 수 있다.

영속적인 통지는 데이터 저장 장치(320)에 유지된다. 일 실시예에 따르면, 영속적인 통지는 레지스트리와 같은, 백앤드 데이터 저장 장치에 보유되므로, 매 부팅마다 "영속"된다. 이들 통지가 영속되기 때문에, 이들 유형의 상태 속성들은 이들이 재부팅(또는 부팅)을 할 때 소프트 리셋(또는 종료) 이전과 동일한 값을 가진다. 일 실시예에 따르면, 디폴트로 상태 속성은 영속된다.

일시적인 통지는 비영속적이므로, 매 부팅마다 영속되지 않는다. 다시 말하면, 장치가 소프트-리셋 (또는 재부팅)된다면 통지 요청은 통지 리스트(340)로부터 삭제된다. 일시적인 통지를 복원하기 위하여, 클라이언트는 상태 속성의 변경에 관한 통지를 수신하는 것을 다시 등록 해야한다(다른 통지 요청을 중개자(335)에게 송신한다).

클라이언트는 상태 변경의 발생시 및/또는 스케줄에 따라서 런칭되는 애플리케이션을 가지는 것 또한 등록할 수 있다. 일반적으로, 통지 중개자(335)는 상태 변경 또는 스케줄링된 시간이 일어났을 때 애플리케이션이 아직 실행되지 않는다면 클라이언트에 의해 지정된 애플리케이션을 수행하는 명령을 발행한다. 일 실시예에 따르면, 클라이언트는 애플리케이션이 런칭될 때 그 애플리케이션으로 전달될 명령 라인 파라미터를 지정할 수 있다. 런칭된 프로세스가 윈도우를 생성한다면 메세지는 통지를 지시하는 그 윈도우로 송신된다. 대상 프로세스가 이미 클라이언트에서 실행되고 있다면, 클라이언트는 단순히 통지 메세지를 수신한다.

클라이언트에게 송신되는 통지는 일괄처리될 수도 있다. 일괄처리되는 상태 속성들은 잦은 값 변경이 일어날 수 있는 상태 속성들에 의한 사용에 의도된다. 상태 변경 값을 "안정"시키는 소정의 기간이 설정된다. 일 실시예에 따르면, 소정의 기간은 200ms로 설정된다. 소정의 기간 동안에 상태 속성값에 아무런 변경이 일어나지 않으면, 통지는 등록된 클라이언트에게 전달된다. 일괄처리 소정 기간을 것이 구성 가능하고 데이터 저장 장치(330)에 저장된다.

데이터 저장 장치(330)는 등록된 상태 속성들 및 다른 정보를 저장하도록 구성된다. 일 실시예에 따르면, 데이터 저장 장치(330)는 마이크로소프트사가 제공하는 윈도우즈 XP 오퍼레이팅 시스템에 제공되는 레지스트리와 같은, 오퍼레이팅 시스템에 제공되는 레지스트리이다. 데이터 저장 장치(330)는 정보가 설정되고 액세스될 수 있는 데이터 저장 장치의 임의의 다른 유형이 될 수도 있다. 데이터 저장 장치(330)는 통지 시스템(300) 내의 다양한 위치에서 보유되는 하나 이상의 데이터 저장 장치 또한 포함할 수 있다.

데이터 저장 장치(330)는 클라이언트(315 및 320)에 의해 액세스될 수 있는 상태 속성 데이터의 디폴트 세트로 미리 로딩될 수도 있다. 상태 속성 데이터를 미리 로딩하는 것은 클라이언트가 상태 속성을 추가하지 않고도 이용가능한 다수의 상태 속성을 작성한다. 예를 들면, 일실시예에 따라, 이하의 상태들은 등록되지 않고도 클라이언트가 이용할 수 있다.

Display Orientation (Resolution, Brightness); Undismissed reminders (Count, Subject, Date, Time; Location); Undismissed alarms (Count, Description, Date, Time); Battery (% remaining, State); Backup battery (% remaining, State); Memory (Program memory free, Program memory used, Storage memory free, Storage memory used); Storage card (Total memory free, Total memory used); Hardware (Flip-phone state (open/closed), Keyboard enabled, Wifi enabled, Bluetooth enabled, Headphones present, Camera present); Messaging (Unread count, Total count, Drafts count, Outbox count); Tasks (High priority count, Due today count, Overdue count); Calendar(Next appointment, Name, Location, Date, Time, POOM ID); All day appointment (Name, Location, Date, Time, POOM ID); Current appointment (Name, Location, Date Time, POOM ID); Current free/busy status; Instant Messenger (Status, Online contacts count; Offline contacts count); Connectivity (Speed, Wifi, Access point, Signal strength, Connection name, Connects to (work, internet), Status); Media player (Status, Playlist (Name, Mode (repeat, shuffle), Track count, Total duration), Track (Type (audio, video), Name, Album, Artists, Track #, Genre, Year, Duration, Play position, Filename, Bit rate)); Sync status; Telephony (Operator, Signal strength, Phone state, Profile, Roaming, Radio state, Active call (Caller name, Caller number), Missed call count, SIM toolkit message.

이에서 알 수 있듯이, 이 상태들은 다수의 다른 애플리케이션을 수용할 수 있다.

일 실시예에 따르면, 상태 속성 데이터는 계층구조로 구성된다. 이 계층구조는 클라이언트가 부모를 참조함으로써 상태 속성들의 그룹을 지정하도록 한다. 상태 속성은 스트링(string), 인티저(integer), 플로트(float), 등과 같은 데이터 타입으로 설정될 수 있다.

클라이언트는 상태 속성의 "사용자 친화적인" 스트링(이름) 표현으로 상태 속성을 식별할 수 있다. 예를 들면, "battery＼a"는 부모 "battery" 하위의 상태 속성 "a"를 참조하고, 마찬가지로 "battery＼b"는 동일한 부모의 하위에 있는 상태 속성 "b"일 수 있다. 공통된 부모의 하위에 있는 상태 속성들의 그룹을 참조할 때면, 그 부모 식별자가 사용될 수 있다. 예를 들면 모든 배터리 상태의 변경에 기반하는 통지를 수신하기 위하여, "battery"가 그 등록에 제공되어, 하나의 이름을 사용하여 배터리 상태 속성 모두를 참조할 수 있다.

중개자(335)는 데이터 저장 장치(330) 내의 상태 속성 유형을 설정/조정/제거하는 액세스를 제어하도록 구성될 수 있다. 예를 들면, 소정의 클라이언트 리스트로의 통지 시스템으로부터 속성을 제거하는 것을 제한하는, 상태 속성에 제약이 있을 수 있다. 상태 속성이 삭제될 때, 그 속성에 관련된 통지에 등록한 클라이언트는 그 속성의 삭제를 통지 받는다.

상술한 바와 같이, 클라이언트(315 및 320)는 상태 속성에 대하여 상태 속성이 변경되는 시점에 대한 통지를 수신하는 것에 관심이 있다는 것을 등록한다. 클라이언트는 상태값에 적용된 조건문이 조건을 만족할 때에, 또는 소정의 스케줄에 기반하여, 그들이 등록한 상태가 변경될 때마다 통지를 수신하는 것을 등록할 수 있다. 조건적 통지는 다수의 다른 조건에 기반할 수 있다. 일 실시예에 따르면, 조건문은 모든, 같다, 같지 않다, 크다, 크거나 같다, 작거나 같다, 작다, 포함한다, ~로 시작한다, ~로 끝난다를 포함한다. 예를 들면, 클라이언트(315)는상실된 호출 카운트 상태 속성이 15보다 크고 호출자 이름이 "Ja"를 포함할 때 통지 중개자(335)에 통지를 수신하는 것을 등록할 수 있다. 조건문들은 클라이언트가 그들이 관심있는 상태 변경 정보를 그들이 관심 없는 상태 변경 정보를 프로세스하지 않고도 수신할 수 있도록 한다.

상태 속성의 변경에 관한 통지를 수신하는 것이 등록된 클라이언트는 통지 리스트(340)에 보유된다. 통지 중개자(335)는 통지 리스트(340)들을 액세스하여 등록된 상태 속성이 변경될 때 통지를 수신해야 하는 클라이언트를 결정한다.

스케줄러(350)는 스케줄에 기반하여 클라이언트에게 통지하고/거나 클라이언트를 활성화시키도록 구성될 수 있다. 스케줄링된 활성화 통지 모드는 통지 중개자(335)에 등록된 단순히 순환하는 스케줄에 기반하여 클라이언트가 통지를 수신하도록 한다. 스케줄은 초, 분, 시간, 일, 주, 또는 월 단위와 같은, 임의의 간격마다 일어나도록 구성될 수 있다. 일 실시예에 따르면, 제1 발생의 날짜/시간에 의해 및 발생 간의 총 시간에 의해 스케줄이 정의된다. 또한, 스케줄은 순환하는 간격 없이 정의될 수 있다. 순환하는 간격이 제공되지 않을 때, 통지는 오직 한번 송신되고 등록은 통지 리스트로부터 제거된다. 또한, 통지가 도착할 때, (통지 요청 동안에 제공된) 지정된 애플리케이션 경로가 발견되지 않는다면, 스케줄링된 통지 등록은 통지 리스트(340)로부터 제거된다.

상태 변경 컴포넌트(310)는 상태가 변경될 때 데이터 저장 장치(330) 내의 상태 속성의 값을 갱신한다. 상태 변경 컴포넌트(310)는 데이터 저장 장치(330)에서 직접적으로 또는 통지 중개자(335)를 통하여 상태를 갱신할 수 있다. 상태가 데이터 저장 장치(330)를 통하여 갱신될 때, 데이터 저장 장치(330)는 통지 중개자(335)에 변경을 전달한다. 상태가 통지 중개자(335)를 통하여 갱신될 때 통지 중개자(335)는 데이터 저장 장치(330)에서 상태를 갱신한다. 그 중 한 경우에서, 통지 중개자(335)는 상태 변경에 기반하여 통지받아야 하는 클라이언트를 결정한다. 통지 중개자(335)는 통지 리스트(340)를 파싱(parsing)하고 상태 변경에 관련된 통지에 등록한 클라이언트를 결정한다. 통지 중개자(335)는 변경된 상태 속성의 값에 임의의 조건문을 적용시키고 조건문이 만족하면 클라이언트에게 통지한다. 상태 변경에 관련된 조건문이 없으면, 클라이언트는 상태 변경을 통지 받는다.

클라이언트(315) 및 클라이언트(320)와 같은, 클라이언트가 통지 중개자(335)로부터 통지를 수신할 때, 클라이언트는 (후술될) 일반 API 내의 함수를 호출하여 상태 변경의 새로운 상태를 검색할 수 있다. 또는, 속성 정보가 통지와 함께 클라이언트에게 직접적으로 전달될 수 있다. 클라이언트가 특정 상태 속성에 관한 통지를 수신하는 것에 더 이상 관심이 없다면, 클라이언트는 상태 속성에 관한 변경 통지를 수신하는 것을 직접 등록 해재시킬 수 있다. 클라이언트(315 및 320)는 또한 일반 API를 이용하여 임의의 시점에서 중개자(335)에게 직접 질의하여 상태 속성의 상태를 검색할 수 있다.

상태 속성값은 또한 통지 중개자(335)에 의하여 캐슁된 속성(345)에 캐슁될 수 있다. 상태 속성값은 다수의 다른 이유로 캐슁될 수 있다. 예를 들면, 상태 속성의 이전값이 상태 속성의 현재값과 비교될 수 있도록 상태 속성 값이 캐슁될 수 있다. 또한, 캐쉬는 상태 속성의 값을 요청하는 빠른 반복 검색을 용이하게 하는 것을 도울 수 있다.

일 실시예에 따르면, 통지 시스템(300)은 저장 장치에 추가 및, 변경 통지 등록 모두를 위해 .NET (관리) 클라이언트를 지원한다.

이하는 상태 관리 통지 시스템(300)을 더 명백하게 하는 몇몇의 예시적인 시나리오이다.

예 1: ISV 서비스

뉴비(Newbie)사의 넘(Norm)은 현재 시즌의 야구 통계자료(예를 들면, 팀, 선수, 점수, 통계 등)의 완전한 데이터베이스를 보유하는 C# 애플리케이션을 작성하였다. 그는 스포츠 웹 사이트에 접속해서 날마다 업데이트 되는 통계자료를 풀다운(pull-down)할 수 있는 간단한 XML 웹-서비스 클라이언트 또한 작성하였다. 애플리케이션이 저장하는 데이터의 양이 상대적으로 크기 때문에, 넘은 그의 애플리케이션이 "팻 파이프(fat pipe)"(예를 들면, 802.1x)가 장치(예를 들면, PPC)에 이용가능할 때에만 데이터를 동기화시키기를 원한다. 그러면 넘은 높은 대역폭 접속이 이용가능할 때 통지 중개자(335)에게 통지를 위한 통지 요청을 송신함으로써 그의 애플리케이션을 등록한다. 넘은 또한 고 대역폭 접속이 이용가능할 때 그의 애플리케이션을 런칭하는 것을 통지 요청에 지정한다. 그 접속과 관련된 상태 변경 컴포넌트가 접속의 상태를 갱신할 때, 이 상태가 그 접속이 고속 접속이라는 것을 나타낸다면 통지 중개자(335)는 넘의 애플리케이션을 활성화 시킨다.

예 2: 코오퍼레이트 LOB(Line of Business) 애플리케이션

앤터프라이즈 개발자(Enterprise developer)인 엘프(Elph)는 보험 정산인 사용을 위한 VB.Net 애플리케이션 기반 필드 서비스 폼을 작성하였다. 이 애플리케이션은 보험 손해 정산인이 부분 #들 및 비용을 검색하고, 노트를 작성하고, 차 계략도 등을 검색하도록 한다. 매일, 보험 정산인은 현장에서 그의 모바일 컴퓨팅 장치를 꺼내 고객측에게 서비스를 제공한다. 애플리케이션은 오늘의 운영을 위해서 자신의 모든 데이터를 데이터 저장 장치에 국부적으로 영속시킨다. 앨프는 애플리케이션이 매 시간마다 장치가 크래들되는 회사의 주 서버로 오프라인 저장 장치를 동기화하는 것을 원한다. 그러므로, 앨프는 그의 애플리케이션을 동기화 크래들 이벤트의 통지를 등록한다. 장치가 크래들되면, 애플리케이션은 통지받고 애플리케이션은 자신의 데이터를 동기화한다.

예 3: 전화 게임

전화 게임 개발자인 고렘(Golem)은 전화용 차세대 멀티플레이어 RPG를 작성한다. 그는 이 게임이 매우 인기 있어서 한번에 수주 및 수개월로 지속되기를 원한다. 고렘의 주요 관심사 중 하나는 사용자 개입 없는 게임 상태의 지속이다. 게임의 획기적인 특징 중 하나는 전화기가 배터리를 다 소모하기 전에 현재 상태를 올바르게 저장하고 사용자가 어떠한 데이터도 잃어버리지 않는다는 것을 보장하는 기능이다. 고렘은 장치가 배터리를 소모시키기 전에 게임 정보가 저장될 것을 보장하기 위하여 그의 애플리케이션이 낮은 배터리 통지를 수신하도록 등록한다.

예 4: 장치 관리 클라이언트

이머징 엔터프라이즈 관리 클라이언트 개발자(emerging Enterprise Management client developer)인 에릭(Eric)은 클라이언트 갱신, 바이러스 스캐닝, 정책 시행, 등을 처리할 수 있는 차세대 모바일 컴퓨팅 장치 및 전화 관리 클라이언트를 만들기를 원한다. C#을 이용하여, 그는 서버 운영 명령에 기반하여 요청을 처리할 수 있는 전력 장치측 클라이언트를 작성한다. 매일 밤 오전 3시에, 에릭은 그의 애플리케이션을 "깨워서" 갱신된 정책, 바이러스 스캐너 서명 등을 위하여 서버에 접촉할 수 있기를 원한다. 이를 달성하기 위하여, 그는 간단히 통지 중개자(335)에 스케줄링된 통지(매일 오전 3시)에 그의 애플리케이션을 등록한다. 에릭은 현재 그의 애플리케이션이 지정된 시간에 동작할 것을 확신한다.

도 4는 본 발명의 양상에 따른 상태 변경 통지 시스템을 위한 프로세스를 도시한다. 블럭이 시작된 후에, 프로세스(400)는 클라이언트가 적어도 하나의 상태 속성의 변경을 통지받을 것을 등록하는 블럭(410)으로 이동한다. 상태 속성이 아직 다른 클라이언트에 의해 모니터링 되지 않았다면, 이 상태 속성은 이용가능한 상태 속성 리스트에 추가된다. 상술한 바와 같이, 이용가능한 속성들의 리스트는 통지 시스템에 미리 로딩된다. 클라이언트는 속성에 대해 이루어진 모든 변경, 조건을 만족하는 변경들에 대한 통지를 수신하는 것을 등록할 수 있으며, 또한 스케줄에 따라 통지를 받을 수 있다.

블럭(420)으로 이동하면, 콜백(callback)이 통지 시스템에 등록되어 등록된 상태 속성에 변경이 이루어질 때, 통지 시스템은 그 변경을 인식한다. 일실시예에 따르면, 통지 중개자는 상태 속성값에 이루어진 변경에 대한 오퍼레이팅 시스템 레지스트리에 콜백을 등록한다.

블럭(430)으로 이동하면, 상태 속성에 관련된 통지 메세지를 수신하도록 클라이언트가 통지 리스트에 추가된다. 통지 리스트에 포함된 클라이언트는 등록된 상태 속성의 변경에 관한 통지를 수신한다.

블럭(440)으로 이동하면, 임의의 등록된 상태 속성에 변경이 이루어질 때 콜백이 수신된다. 일 실시예에 따르면, 콜백은 상태 속성 변경들을 식별하는 식별자 및 상태 속성의 현재값을 포함한다.

블럭(450)으로 이동하면, 상태 변경 정보가 프로세싱된다. 일반적으로, 상태 변경 정보를 프로세싱하는 것은 임의의 조건문, 스케줄, 일괄처리, 또는 애플리케이션 런칭 조건이, 변경된 상태 속성에 대하여 등록된 클라이언트 각각에 적용되는지 판정하는 것을 포함한다(도 5 및 관련된 논의에 기술됨).

도 5는 본 발명의 양상들에 따른 상태 변경 정보를 프로세싱하는 프로세스를 도시한다. 시작 블럭 후에, 프로세스(500)는 변경된 상태 속성에 대한 상태 변경에 관련된 통지를 수신하기 위하여 등록된 클라이언트가 액세스되는 블럭(510)으로 이동한다. 일 실시예에 따르면, 통지 리스트가 액세스되어 변경된 상태 속성에 대하여 등록된 클라이언트를 결정한다.

판정 블럭(520)으로 이동하면, 클라이언트에게 통지하기 이전에, 클라이언트가 상태 속성에 적용될 임의의 조건문을 지정했는지 여부에 대한 판정이 이루어진다.

조건식이 통지 요청에 관련되면, 프로세스는 조건이 만족하는지 여부에 대한 판정이 이루어지는 판정 블럭(530)으로 이동한다. 조건이 만족되거나, 클라이언트가 임의의 조건문들을 지정하지 않았다면, 프로세스는 클라이언트가 상태 속성의 변경에 응답하여 애플리케이션을 런칭하도록 지정했는지 여부에 대한 판정이 이루어지는 판정 블럭(540)으로 이동한다. 클라이언트가 애플리케이션을 런칭하도록 지정했을 때, 프로세스는 애플리케이션이 아직 실행되지 않았으면 그 애플리케이션이 런칭되는 블럭(550)으로 이동한다. 클라이언트가 애플리케이션을 런칭하는 것을 지정하지 않았을 때, 또는 애플리케이션이 블럭(550)에서 런칭되었을 때, 프로세스는 클라이언트가 상태 변경을 통지받는 블럭(560)으로 이동한다.

그 다음 프로세스는 상태 속성의 변경에 관한 통지를 수신하는 것이 등록된 클라이언트가 더 있는지 여부에 대한 판정이 이루어지는 판정 블럭(570)으로 이동한다. 다른 클라이언트가 있다면, 프로세스는 블럭(510)으로 리턴한다. 다른 클라이언트가 없다면, 프로세스는 종료 블럭으로 이동하여 다른 행위를 프로세스하도록 리턴한다.

상태 속성 타입 및 모드

본 발명의 일 실시예에 따라서, 2개의 API가 통지 시스템에서 상태 정보를 액세스하는 데에 이용될 수 있다. 원시 또는 기초적인 API가 제공되고 클라이언트에게 관리 API가 제공된다. 관리 API는 원시 API를 액세스하여 자신의 오퍼레이션을 수행한다.

이하는 본 발명의 양상들에 따르는, 예시적인 원시 API이다.

#define E_ALREADY_REGISTERED ERROR_ALREADY_REGISTERED

#define E_DATATYPE_MISMATCH ERROR_DATATYPE_MISMATCH

#define E_INSUFFICIENT_BUFFER ERROR_INSUFFICIENT_BUFFER

#define E_INVALID_HANDLE ERROR_INVALID_HANDLE

#define E_NOT_FOUND ERROR_NOT_FOUND

#define E_NOT_READY ERROR_NOT_READY

DECLARE_HANDLE(HREGNOTIFY); // 일시적인 통지 핸들

// ***********************************************************

// 이뉴멀레이션(Enumeration) 이름: REG_COMPARISONTYPE

// 목적: 조건적 변경 통지를 위하여 상태 속성값이

// 대상값과 비교되는 방법을 정의하는 데에 이용된다.

// REG_COMPARISONTYPE을 실행할 때, 변경된 값은

// l-value로 사용된다. 즉, REG_CT_LESS는

// 변경값이 대상값보다 작은 경우에 통지를 시작하는 것을 의미한다.

//

// 설명:

// 이하는 비교가 행해졌을 때 어떤 진술이 참일지를 나타낸다.

// 케이스 인센시티브(case insensitive)한 CompareString이 스트링들을 비교하는 데에

// 사용되고, 이하의 정보가 REG_COMPARISONTYPE값의 의도를 명백하게 하는 데에

// 사용된다.

// "cv"는 변경된 값을 나타내고 "psz"나 "dw"는 NOTIFICATIONCONDITION 구조에서

//지정된 TargetValue를 나타낸다고 하자. "l"은 psz (wcslen(psz))에서 지정된

// 스트링의 길이를 나타내고 "cvl"는 변경된 값 (wcslen(cv))의 스트링 길이를

// 나타낸다.

// REG_SZ REG_DWORD

// REG_CT_EQUAL | (0 == strcmp(cv, psz)) | (cv == dw) |

// REG_CT_NOT_EQUAL | (0 != strcmp(cv, psz)) | (cv != dw) |

// REG_CT_GREATER | (0 < strcmp(cv, psz)) | (cv > dw) |

// REG_CT_GREATER_OR_EQUAL | (0 <= strcmp(cv, psz)) | (cv >= dw) |

// REG_CT_LESS | (0 > strcmp(cv, psz)) | (cv < dw) |

// REG_CT_LESS_OR_EQUAL | (0 >= strcmp(cv, psz)) | (cv <= dw) |

// REG_CT_CONTAINS | (0 != strstr(cv, psz)) | N/A |

// REG_CT_STARTS_WITH | (0 == strncmp(cv, psz, l)) | N/A |

// REG_CT_ENDS_WITH | (0 == strcmp(cv+cvl-l, psz)) | N/A |

// ***************************************************

typedef enum tagREG_COMPARISONTYPE

{

REG_CT_EQUAL,

REG_CT_NOT_EQUAL,

REG_CT_GREATER,

REG_CT_GREATER_OR_EQUAL,

REG_CT_LESS,

REG_CT_LESS_OR_EQUAL,

REG_CT_CONTAINS,

REG_CT_STARTS_WITH,

REG_CT_ENDS_WITH

} REG_COMPARISONTYPE;

// ***********************************************************

// 스트럭쳐 이름: NOTIFICATIONCONDITION

//

// 목적: 속성 상태 변경 통지가 시작되어야 하는 조건을 정의하는 데에 이용된다.

//

// 설명:

// REG_COMPARSIONTYPE ctComparisonType - TargetValue에서 지정된 값과

// 변경된 값을 비교하는 방법이다.

// DWORD dwMask - 이 값이 0으로 설정되지 않았다면, TargetValue는 DWORD로 // 해석된다. 이러한 마스크는 비교가 일어나기 전에 변경된 DWORD값에

// 적용되고, 마스크는 TargetValue에 적용되지 않는다. 이 값이 0으로

// 설정되면 TargetValue는 스트링으로 해석된다.

// union TargetValue - dwMask가 0으로 설정되면 psz와 변경된 값 간의

// 비교가 이루어졌다. dwMask가 0이 아닌 임의의 값으로 설정된다면 dw와

// 마스크된 변경값(dwMask에 나와있음) 간의 비교가 이루어진다.

// 변경된 값이 REG_SZ 또는 REG_DWORD 타입이 아니거나, 변경된 값이 REG_DWORD // 타입이고 dwMask가 0으로 설정되거나, 변경된 값이 REG_SZ 타입이고 dwMask가

// 0으로 설정되지 않는다면, 통지는 무시된다. 변경된 값이 삭제되고 dw와의

// 비교가 이루어지고자 한다면, 0이 변경된 값으로 이용되고 이 비교는 평소와

// 같이 진행된다. 이 변경된 값이 삭제되고 psz와의 비교 비교가 이루어지고자

//한다면, NULL이 변경된 값으로 이용되고 오직 REG_CT_EQUAL 및 REG_CT_NOT_EQUAL

//만이 이 비교에 의해 진행되고, 임의의 다른 ctComparisonType이 사용된다면

// 삭제 통지는 무시된다.

// *****************************************************

typedef struct tagNOTIFICATIONCONDITION

{

REG_COMPARISONTYPE ctComparisonType;

DWORD dwMask;

union

{

LPCTSTR psz;

DWORD dw;

} TargetValue;

} NOTIFICATIONCONDITION;

// 함수 프로토타입: REGISTRYNOTIFYCALLBACK

//

// 목적: RegisterNotifyCallback에 의하여 사용되는 콜백의 프로토타입을

// 정의한다.

//

// 독립 변수:

// IN HREGNOTIFY hNotify - 유효한 HREGNOTIFY의 핸들

// 이는 RegistryNotifyCallback으로부터 반환된 것과 동일한 핸들

// IN DWORD dwUserData - RegistryNotifyCallback에 전달되었던 사용자 데이터

// IN const PBYTE pData - 새로운 값을 위한 그 새로운 값으로의 포인터, 이

// 값이 삭제되었다면 NULL로 설정된다.

// IN const UINT cbData - pData가 가리키는 바이트수, 이 값이

// 삭제되면 0으로 설정된다.

//

// 설명:

// 이 콜백은 RegistryNotifyCallback을 사용하여 통지에 등록된 클라이언트에게 // 통지하는 데에 사용된다. 통지가 더 이상 요구되지 않으면 이 콜백 내에서

// RegistryCloseNotification을 호출하는 것이 안전하다.

//

// **************************************************

typedef void (*REGISTRYNOTIFYCALLBACK)(HREGNOTIFY hNotify,

DWORD dwUserData,

const PBYTE pData,

const UINT cbData);

// *************************************************************

// 함수 이름: RegistryGetDWORD

//

// 목적: REG_DWORD 레지스트리 값을 판독하는 데에 사용된다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// IN LPCTSTR pszSubKey - 하위에 값이 저장된 키(이 값이 널이라면

// pszValuename은 hKey 하위에 있다고 가정한다)

// IN LPCTSTR pszValueName - 검색할 값의 이름(디폴트 값을 검색하는 NULL

// 값일 수 있다)

// OUT DWORD * pdwData - 값과 관련되는 데이터를 수신할 버퍼로의 포인터

//

// 반환값:

// HRESULT

// S_OK - 데이터가 버퍼에 복사되었다

// E_INVALIDARG - hKey 또는 pdwData가 무효하다

// E_DATATYPE_MISMATCH - 값이 REG_DWORD 타입이 아니다

// FACILITY_WIN32 HRESULT로 래핑(wrap)된 RegOpenKeyEx 또는

// RegQueryValueEx로부터 반환되는 에러값

//

// 결과:

// SUCCEEDED - pData는 값에 관련된 데이터를 가리킨다.

// FAILED - 변화없다.

//

// 설명:

// 값에 관련된 DWORD는 pData가 가리키는 버퍼에 복사된다.

// hKey+pszSubKey가 가리키는 키가 존재하지 않는다면,

// RegistryGetDWORD는 RegOpenKey를 사용하여 그 키를 액세스하기 때문에 실패

// 할 것이다.

// *****************************************************

HRESULT WINAPI RegistryGetDWORD(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

DWORD * pdwData);

// *******************************************************

// 함수 이름: RegistryGetString

//

// 목적: REG_SZ 레지스트리 값을 판독하는 데에 사용된다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// pszValuename은 hKey 하위에 있다고 가정한다)

// 값일 수 있다)

// OUT LPTSTR pszData - 값과 관련되는 데이터를 수신할 버퍼로의 포인터

// IN UINT cchData - pData가 가리키는 버퍼의 캐릭터들의 길이인 변수로의

// 포인터

//

// 반환값:

// HRESULT

// S_OK - 데이터가 버퍼에 복사되었다

// E_INVALIDARG - hKey 또는 pszData는 무효하다

// E_DATATYPE_MISMATCH - 이 값은 REG_SZ 타입이 아니다.

// E_INSUFFICIENT_BUFFER - cchData에 의해 결정된, pszData가 가리키는 버퍼

// 의 크기가 스트링을 수용하기에는 충분하지 않다.

// FACILITY_WIN32 HRESULT로 래핑된 RegOpenKeyEx 또는 RegQueryValueEx로부터

// 반환되는 에러값

//

// 결과:

// SUCCEEDED - pData는 값과 연관되는 데이터를 가리킨다.

// FAILED - 변화없다

//

// 설명:

// 값과 관련된 스트링은 pData가 가리키는 버퍼에 복사된다.

// hKey+pszSubKey가 가리키는 키가 존재하지 않는다면,

// RegistryGetString은 RegOpenKey를 사용하여 그 키를 액세스하기 때문에 실패

// 할 것이다.

//

// **************************************************************

HRESULT WINAPI RegistryGetString(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

LPTSTR pszData,

UINT cchData);

// ************************************************************

// 함수 이름: RegistrySetDWORD

//

// 목적: REG_DWORD 레지스트리 값을 설정하는 데에 이용된다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// pszValuename은 hKey 하위에 있다고 가정한다)

// IN LPCTSTR pszValueName - 설정할 값의 이름(디폴트 값을 설정하는 NULL

// 값일 수 있다)

// IN DWORD dwData - 새로운 값

//

// 반환값:

// HRESULT

// S_OK - pszValueName에 대한 데이터 값이 dwData의 데이터로 변경되었다.

// E_INVALIDARG - hKey가 무효하다.

// E_DATATYPE_MISMATCH - 값이 REG_DWORD 타입이 아니다.

// FACILITY_WIN32 HRESULT로 래핑된 RegOpenKeyEx 또는 RegQueryValueEx로

// 부터 반환되는 에러값

//

// 결과:

// SUCCEEDED - 값과 연관된 데이터가 변경되었다.

// FAILED - 변화없다.

//

// 설명:

// 값과 연관되는 데이터가 새로운 값으로 변경된다.

// hKey+pszSubKey가 가리키는 키가 존재하지 않는다면, RegistrySetDWORD는

// RegOpenKey를 사용하여 그 키를 액세스하기 때문에 실패할 것이다.

//

// ************************************************************

HRESULT WINAPI RegistrySetDWORD(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

DWORD dwData);

// *************************************************************

// 함수 이름: RegistrySetString

//

// 목적: REG_SZ 레지스트리 값을 설정하는 데에 사용된다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// pszValuename은 hKey 하위에 있다고 가정한다)

// 값일 수 있다)

// IN LPCTSTR pszData - 새로운 값. 이 스트링은 널에 의해 종결된다.

//

// 반환값:

// HRESULT

// S_OK - pszValueName에 대한 데이터 값이 pszData의 데이터로 변경되었다.

// E_INVALIDARG - hKey 또는 pszData가 무효하다

// E_DATATYPE_MISMATCH - 이 값은 REG_SZ 타입이 아니다.

// FACILITY_WIN32 HRESULT로 래핑되는 RegOpenKeyEx 또는

// RegQueryValueEx로부터 반환된 에러값

// StringCbLength로부터 반환된 에러 HRESULT.

//

// 결과:

// SUCCEEDED - 값에 관련된 데이터가 변경되었다.

// FAILED - 변화없다.

//

// 설명:

// 값과 연관되는 데이터가 새로운 값으로 변경된다. hKey+pszSubKey가 가리키는

// 키가 존재하지 않으면, RegistrySetString은 RegOpenKey를 사용하여 키를

// 액세스하기 때문에 실패할 것이다.

//

// **************************************************************

HRESULT WINAPI RegistrySetString(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

LPCTSTR pszData);

// ***************************************************************

// 함수 이름: RegistryTestExchangeDWORD

//

// 목적: 조건에 기반하여 어터믹(atomic)하게 값을 설정하는 데에 이용한다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// pszValueName은 hKey 하위에 있다고 가정한다)

// 값일 수 있다)

// IN DWORD dwOldValue - 체크할 값

// IN DWORD dwNewValue - 조건적으로 설정될 값

//

// 반환값:

// HRESULT

// S_OK - 데이터 값이 dwNewValue로 변경되었다.

// S_FALSE - pszValueName와 관련된 DWORD값이 dwOldValue와 동일하지 않기

// 때문에 대상값이 dwNewValue로 설정되지 않았다.

// E_INVALIDARG - 핸들 또는 전달된 포인터들 중 하나가 무효하였다.

// E_DATATYPE_MISMATCH - 이 값은 REG_DWORD 타입이 아니다.

// E_NOT_FOUND - 지정된 키의 하위에서 이 값을 발견할 수 없다.

// FACILITY_WIN32 HRESULT로 래핑된 에러값.

//

// 결과:

// SUCCEEDED - pszData와 연관된 데이터 값이 dwOldValue였고 현재는

// dwNewValue이다.

// FAILED - 변화없다.

//

// 설명:

// 이 함수는 내부락(interlock)된 함수이다. - 다시 말하면, 이는 어터믹하다고

// 간주된다. 이 함수는 pszValueName와 관련된 DWORD값이 OldValue와 동일한지

// 알기 위한 검사를 한다. 동일하다면, 함수는 대상을 NewValue로 설정하고,

// 그렇지 않으면, 실패한다.

//

// *******************************************************

HRESULT WINAPI RegistryTestExchangeDWORD(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

DWORD dwOldValue,

DWORD dwNewValue);

// **************************************************

// 함수 이름: RegistryNotifyApp

//

// 목적: 지정된 값이 변경되었을 때 애플리케이션이 런칭되거나 통지되는 것을

// 요청하는 데에 이용된다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// pszValuename은 hKey 하위에 있다고 가정한다)

// IN LPCTSTR pszValueName - 변경 통지가 요청된 값의 이름(디폴트 값을 지정

// 하는 NULL값일 수 있다)

// IN LPCTSTR pszName - 이 통지 요청을 나타내는 사용자 정의 스트링,

// 이 스트링은 통지가 더 이상 필요 없을 때

// RegistryStopNotification으로 전달되어야 한다.

// IN LPCTSTR pszApp - 런칭될 실행 파일로의 경로인 스트링에 대한 포인터.

// IN LPCTSTR pszClass - 일단 실행 파일이 런칭됐거나, 이것이

//이미 실행된 IN LPCTSTR pszWindow라면, 이 윈도우 이름을 가지는 윈도우 및

//클래스 타입은 프로세스에 위치되고 통지는 이곳으로 전달된다.

//이들 파라미터가 둘다 널이라면 이 함수는 그 애플리케이션을 런칭하기만 할 것

//이다.

// IN UINT msg - 윈도우로 전달될 메세지

// IN NOTIFICATIONCONDITION * pCondition - 새로운 레지스트리 값과의

// 변경의 비교가 TRUE일 때,

// 이 변경 통지가 송신되어야 하는 조건

// (임의의 변경이 통지를 발생하라고

// 지시하는 NULL일 수 있다.)

//

// 반환값:

// HRESULT

// S_OK - 통지에 대한 요청이 통지 리스트에 추가되었다.

// E_INVALIDARG - hKey, pszApp, 또는 pszName이 무효하다.

// E_ALREADY_REGISTERED - pszName에 의해 지정된 이름과 동일한 이름을 가진

// 통지가 이미 존재한다.

// FACILITY_WIN32 HRESULT로 래핑된 에러값.

//

// 결과:

// SUCCEEDED - 호출자는 현재 매 시간마다 이 값에 이루어진 변경을 통지받을

// 것이다.

// FAILED - 변화없다.

//

// 설명:

// 통지 요청이 통지 리스트에 추가된다. 호출자는

//RegistryStopNotification을 호출하여 추가적인 통지를 정지시킨다. 이러한

//유형의 통지 요청은 영속된다. 즉, 통지 요청은 장치가 재부팅되는 경우에도

//활성화될 것이다. 통지 중에, 이 함수는 pszApp에 지정된 이름을 가지는 실행

//파일이 pszClass 및 pszWindow에 의해 지정된 클래스 이름 및 윈도우 이름에 의

//해 FindWindow를 실행함으로써 이미 실행되고 있는지를 판정하여, 그렇지 않으

// 면, 애플리케이션을 런칭한다. 애플리케이션으로 전달되는 명령 라인은 사용자

//에 의해 지정되는 임의의 명령 라인과 함께 pszApp 스트링에서 지정되어야 하며,

//이하 기술된다:

// /notify "pszName"

// pszName - pszName 파라미터 내의 함수로 전달되는 핸들 스트링

// 애플리케이션이 런칭된 후에 FindWindow는 pszClass 및 pszWindow에서 지정

//된 클래스 이름 및 윈도우 이름을 가지는 윈도우를 찾도록 수행된다. 윈도우가

//발견되지 않으면, msg에 의해 지정된 메세지는 PostMessage를 통해,

//RegistryNotifyWindow로 포스팅(post)된다. PostMessage로의 파라미터는 이하와

//같다.

// WPARAM - REG_DWORD 타입의 값에서는 새로운 값이거나 이 값이 삭제되어

// 있다면 0이다. 모든 다른 타입에 대하여 이 값은 0이다.

// LPARAM - 0

// msg 파라미터는 RegistryNotifyApp로의 각각의 호출에 대하여 고유하여

//클라이언트가 복수의 통지들 간에서 구별할 수 있어야 한다. 클라이언트는 값이

//추가될 때 및 변경 중일 때 통지될 것이다. 통지가 도착했을 때, pszApp가

//가리키는 애플리케이션이 런칭될 수 없거나 pszClass 타입의 클래스를 가지는

//윈도우가 발견되지 않거나 PostMessage가 실패하면, 통지는 통지 리스트로부터

//제거될 것이다.

//

// *****************************************************************

HRESULT WINAPI RegistryNotifyApp(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

LPCTSTR pszName,

LPCTSTR pszApp,

LPCTSTR pszClass,

LPCTSTR pszWindow,

UINT msg,

NOTIFICATIONCONDITION * pCondition);

// **************************************************************

// 함수 이름: RegistryNotifyWindow

//

// 목적: 지정된 값이 변경되었을 때 윈도우가 통지되는 것을 요청하는 데에

//사용된다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// IN LPCTSTR pszSubKey - 하위에 변수가 저장된 키(이 값이 널이라면

// pszValuename은 hKey 하위에 있다고 가정한다)

// IN LPCTSTR pszValueName - 변경 통지가 요청되는 값의 이름 (디폴트 값을

// 나타내는 NULL값일 수 있다.)

// IN HWND hWnd - 메세지가 송신될 윈도우의 핸들

// IN UINT msg - 윈도우로 전달될 메세지

// IN DWORD dwUserData - 통지와 함께 사용자에게 되돌아올 사용자 데이터.

// IN NOTIFICATIONCONDITION * pCondition - 새로운 레지스트리 값들과의

// 변경의 비교가 TRUE일 때,

// 이 변경 통지가 송신되어야 하는 조건

// (임의의 변경이 통지를 발생하라고

// 지시하는 NULL일 수 있다.)

// OUT HREGNOTIFY * phNotify - 통지 요청의 핸들을 수신한다.

// 이 키 상의 통지가 더 이상 필요하지 않을 때 이 핸들은

// RegistryCloseNotification을 이용하여 닫힌다.

//

// 반환값:

// HRESULT

// S_OK - 통지에 대한 요청이 통지 리스트에 추가되었다.

// E_INVALIDARG - hKey, phNotify 또는 hWnd가 무효하다.

// FACILITY_WIN32 HRESULT로 래핑된 에러값

//

// 결과:

// 것이다.

// FAILED - 변화없다

//

// 설명:

// msg 파라미터는 RegistryNotifyWindow로의 각각의 호출에 대하여 고유하여

//클라이언트가 복수의 통지들 간에 구별할 수 있어야 한다. 통지 요청은 통지

//리스트에 추가된다. 호출자는 RegistryCloseNotification을 호출하여 더

//이상의 통지를 정지시키고 통지 핸들을 닫는다. 통지 요청의 이러한 유형은

//일시적이다. 즉, 장치가 재부팅되면 통지 요청이 더 이상 존재하지 않을 것이다.

//pszValueName에 의해 지정된 값이 변경되면, Postmessage를 통해 클라이언트가

//통지받는다. PostMessage가 실패하거나 hWind에 의해 지정된 윈도우가 더 이상

//유효하지 않다면 통지 요청은 통지 큐로부터 제거되고 phNotify에서 반환된

//핸들은 닫힌다.

// PostMessage에 전달되는 파라미터는 다음과 같다.

// WPARAM - REG_DWORD 타입의 값에서는 새로운 값이거나 이 값이 삭제되면

// 0이다. 모든 다른 타입에서 이 값은 0이다.

// LPARAM - dwUserData에 전달된 값

// RegistryNotifyWindow로 호출한 시점에 이 값이 존재하지 않으면,

// 클라이언트는 이 값이 추가될 때 통지받을 것이다.

//

// *************************************************************

HRESULT WINAPI RegistryNotifyWindow(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

HWND hWnd,

UINT msg,

DWORD dwUserData,

NOTIFICATIONCONDITION * pCondition,

HREGNOTIFY * phNotify);

// ****************************************************************

// 함수 이름: RegistryNotifyMsgQueue

//

// 목적: 지정된 값이 변경되었을 때 메세지 큐가 통지되는 것을 요청하는 데에

// 사용된다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들.

// pszValueName은 hKey 하위에 있다고 가정한다)

// 지시하는 NULL일 수 있다)

// IN LPCTSTR pszMsgQueue - 통지할 메세지 큐의 이름인 스트링에 대한

// 포인터. 메세지 큐가 아직 생성되지 않았다면, RegistryNotifyMsgQueue가

// 그 큐를 생성할 것이다.

// IN DWORD dwUserData - 통지와 함께 사용자에게 돌려보내질 사용자 데이터

// IN NOTIFICATIONCONDITION * pCondition - 새로운 레지스트리 값과의

// 변경의 비교가 TRUE일 때,

// 이 변경 통지가 송신되어야 하는 조건

// (임의의 변경이 통지를 발생하라고

// 지시하는 NULL일 수 있다.)

// OUT HREGNOTIFY * phNotify - 통지 요청의 핸들을 수신한다.

// 이 키 상의 통지가 더 이상 필요하지 않을 때 이 핸들은

// RegistryCloseNotification을 이용하여 닫힌다

//

// 반환값:

// HRESULT

// S_OK - 통지에 대한 요청이 통지 리스트에 추가되었다.

// E_INVALIDARG - hKey, phNotify, 또는 pszMsgQueue가 무효하다.

// FACILITY_WIN32 HRESULT로 래핑된 에러값

//

// 결과:

// 것이다.

// FAILED - 변화없다.

//

// 설명:

// 통지 요청이 통지 리스트에 추가된다. 호출자는 RegistryCloseNotification

//을 호출하여 추가적인 통지를 정지시키고 통지 핸들을 닫는다..

//이러한 유형의 통지 요청은 일시적이다. 즉, 장치가 재부팅된다면

//통지 요청은 더 이상 존재하지 않을 것이다. 클라이언트는 메세지 큐를 통하여

//변경을 통지받을 것이다. 클라이언트가 통지 받으면, 변경된 키에 관한 정보는

//ReadMsgQueue 함수를 이용하여 검색될 수 있다. 리턴된 데이터는 다음의 포멧으

//로 존재한다.

// hNotify - phNotify에서 반환되는 것과 동일한 hNotify

// dwUserData - dwUserData로 전달되는 사용자 데이터

// byte count - 첨부된 바이트 수(삭제되면 0 값을 가진다.)

// new value - pszValueName의 새로운 값

// 이 값이 RegistryNotifyMsgQueue로 호출한 시점에 존재하지 않는다면,

// 클라이언트는 이 값이 추가될 때 통지받을 것이다.

//

// ************************************************************

HRESULT WINAPI RegistryNotifyMsgQueue(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

LPCTSTR pszMsgQueue,

DWORD dwUserData,

NOTIFICATIONCONDITION * pCondition,

HREGNOTIFY * phNotify);

// **************************************************************

// 함수 이름: RegistryNotifyCallback

//

// 목적: 지정된 값이 변경되었을 때 콜백이 통지되는 것을 요청하는 데에 사용된

// 다.

//

// 독립 변수:

// IN HKEY hKey - 현재 열린 키, 또는 소정의 루트값의 핸들

// pszValueName은 hKey 하위에 있다고 가정한다)

// 나타내는 NULL값일 수 있다.)

// IN REGISTRYNOTIFYCALLBACK pfnRegistryNotifyCallback - 통지가 도착할 때

// 콜백될 함수로의 포인터

// IN DWORD dwUserData - 통지와 함께 사용자에게 되돌아갈 사용자 데이터

// IN NOTIFICATIONCONDITION * pCondition - 새로운 레지스트리 값과의

// 변경의 비교가 TRUE일 때,

// 이 변경 통지가 송신되어야 하는 조건

// (임의의 변경이 통지를 발생하라고

// 지시하는 NULL일 수 있다.)

// OUT HREGNOTIFY * phNotify - 통지 요청의 핸들을 수신한다.

// 이 키 상의 통지가 더 이상 필요하지 않을 때 이 핸들은

// RegistryCloseNotification을 이용하여 닫혀야 한다.

//

// 반환값:

// HRESULT

// S_OK - 통지에 대한 요청이 통지 리스트에 추가되었다.

// E_INVALIDARG - hKey, phNotify, 또는 pfnRegistryNotifyCallback이

// 무효하다

// FACILITY_WIN32 HRESULT로 래핑된 에러값

//

// 결과:

// 것이다.

// FAILED - 변화없다.

//

// Description:

//을 호출하여 추가적인 통지를 정지시키고 통지 핸들을 닫는다.

// 이러한 유형의 통지 요청은 일시적이다. 즉, 장치가

// 재부팅된다면 통지 요청은 더 이상 존재하지 않을 것이다. 클라이언트는

//콜백을 통하여 변경을 통지 받을 것이다. 이 값이 RegistryNotifyCallback으로

// 호출한 시점에 존재하지 않으면, 클라이언트는 이 값이 추가될 때 통지받을

//것이다.

//

// **************************************************************************

HRESULT WINAPI RegistryNotifyCallback(HKEY hKey,

LPCTSTR pszSubKey,

LPCTSTR pszValueName,

REGISTRYNOTIFYCALLBACK pfnRegistryNotifyCallback,

DWORD dwUserData,

NOTIFICATIONCONDITION * pCondition,

HREGNOTIFY * phNotify);

// ************************************************************

// 함수 이름: RegistryCloseNotification

//

// 목적: 통지 리스트로부터 통지에 대한 요청을 제거하고 통지 핸들을 닫는 데에

//사용된다.

//

// 독립 변수:

// IN HREGNOTIFY hNotify - 유효한 HREGNOTIFY의 핸들, 반환된

//RegistryNotify* 함수 중 하나었어야 한다.

//

// 반환값:

// HRESULT

// S_OK - 통지 요청이 리스트로부터 제거되었다.

// E_INVALID_HANDLE - hNotify가 무효하다.

// FACILITY_WIN32 HRESULT로 래핑된 에러값

//

// 결과:

// SUCCEEDED - 통지 요청이 제거되었고, hNotify는 현재 무효한 핸들이다.

// FAILED - 변화없다.

//

// 설명:

// 통지 리스트가 hNotify로의 참조를 위하여 검색되며, 발견되면

// 이들 통지 리스트는 큐로부터 제거되고 hNotify와 관련된 메모리를 비운다.

// 클라이언트로에 아직 발송되지 않은 임의의 통지는 상실될 것이다.

//

// **************************************************************

HRESULT WINAPI RegistryCloseNotification(HREGNOTIFY hNotify);

// ***************************************************************

// 함수 이름: RegistryStopNotification

//

// 목적: 통지 리스트로부터 영속적인 통지에 관한 요청을 제거하는 데에

// 사용된다.

//

// 독립 변수:

// IN LPCTSTR pszName - 이미 등록된 영속적인 통지를 나타내는 스트링

//

// 반환값:

// HRESULT

// S_OK - 통지 요청이 리스트로부터 제거되었다.

// E_INVALIDARG - pszName이 무효하다.

// FACILITY_WIN32 HRESULT로 래핑된 에러값

//

// 결과:

// SUCCEEDED - 통지 요청이 제거되었다.

// FAILED - 변화없다.

//

// 설명:

// 통지 리스트가 통지로의 참조를 위하여 검색되며, 발견된다면,

// 이들 통지 리스트는 큐로부터 제거된다. 클라이언트에 아직 발송되지 않은

// 임의의 통지는 상실된다.

//

// ****************************************************************

HRESULT WINAPI RegistryStopNotification(LPCTSTR pszName);

// ************************************************************

// 함수 이름: RegistryBatchNotification

//

// 목적: 자주 일어나는 통지를 일괄처리하는 데에 이용된다.

//

// 독립 변수:

// IN HREGNOTIFY hNotify - 무효한 HREGNOTIFY로의 핸들, RegistryNotify*

// 함수 중 하나로 반환되었다.

// IN DWORD dwMillisecondsIdle - 밀리세컨드의 수, 이 값은 통지가 발생되기

// 전에는 일정하다.

// IN DWORD dwMillisecondsMax - 제1 변경이 일어나는 시간과 통지가 송신되는

// 시간 간의 밀리세컨드의 최대 수

//

// 반환값:

// HRESULT

// S_OK - 통지 요청이 리스트로부터 제거되었다.

// E_INVALIDARG - dwMillisecondsIdle이 INFINITE로 설정되있.

// E_INVALID_HANDLE - hNotify가 무효하다.

// FACILITY_WIN32 HRESULT로 래핑되는 에러값

//

// 결과:

// SUCCEEDED - 새로운 일괄처리 횟수가 설정된다.

// FAILED - 변화없다.

//

// 설명:

// 값이 변경될 때, 통지 시스템은 dwMillisecondsIdle 밀리세컨드만큼 기다리

//고 그 다음 통지를 송신한다. 기다리는 시간 동안 다른 변경이 일어나면 타이머

//가 재설정되고 통지 시스템은 다른 dwMillisecondsIdle 밀리세컨드만큼 기다려

//서 통지를 송신할 것이다. dwMillisecondsIdle가, 통지가 송신되는 것을 결코

//방지하지 않는 것을 보장하기 위해서, dwMillisecondsMax가 사용된다.

//dwMillisecondsMax는 제1 통지가 도착하는 시간으로부터 통지가 송신되는 시간까

//지 지나는 것이 허용되는 최대 밀리세컨드 수이다. dwMillisecondsMax가

//INFINITE라고 설정되면 통지는 값이 아이들(idle)이 될 때까지 일괄처리할 것이

//다. dwMillisecondsIdle은 INFINITE일 수 없다.

//

// *************************************************************

HRESULT WINAPI RegistryBatchNotification(HREGNOTIFY hNotify,

DWORD dwMillisecondsIdle,

DWORD dwMillisecondsMax);

HRESULT WINAPI RegistryScheduleNotifications(SYSTEMTIME * pstStart,

DWORD dwIntervalMinutes,

RSN_BEHAVIOR rsnBehavior,

LPCTSTR pszName,

LPCTSTR pszApp,

LPCTSTR pszClass,

LPCTSTR pszWindow,

UINT msg);

관리 API

이하는 예시적인 관리 API이다 :

namespace A.Mobile

{

/// 장치가 스탠바이에 있을 때 이벤트가 발생하면 일어나는 것들을 명시하는

//데에 사용된다.

public enum StandbyBehavior

{

/// 이벤트를 전혀 일으키지 않는다.

Ignore,

/// 장치를 스탠바이로부터 가져오고 이벤트를 일으킨다.

Wake,

/// 어떤 다른 것에 의해 일단 장치가 깨어나면 이벤트를 일으킨다.

Delay

}

public interface IAppLaunchable

{

/// 이 통지에 관한 고유한 이름

public string appLaunchId{ get; }

/// 특정 실행 파일에 대한 통지 및 명령 라인 param을 등록한다.

/// 호출될 때까지, 통지는 활성화되지 않는다.

/// <param name="appLaunchId">

/// 이 통지에 대한 고유한 식별자.

/// 애플리케이션이 닫힐/재시작될 때 이것을 열어 백업할 때 이용한다.

/// 이 ID가 이미 사용중일 때 예외를 던진다.

/// </param>

/// <param name="filename">

/// 통지가 일어날 때 런칭될 애플리케이션

/// null이나 emply일 때, 호출 실행파일이 이용된다.

/// </param>

///<param name="parameters">애플리케이션에 송신될 명령 라인 파라미터</param>

void EnableAppLaunch( string appLaunchId, string filename, string parameters );

/// 명령 라인 param들을 가지고 있지 않는 특정 실행 파일에 이 통지를 등

///록한다.

/// 이것이 호출될 때까지, 통지는 비활성화된다.

/// <param name="appLaunchId">

/// 이 통지를 위한 고유한 식별자.

/// 이 ID가 이미 사용중일 때 예외를 던진다.

/// </param>

/// <param name="filename">통지가 일어날 때 시작될 애플리케이션</param>

void EnableAppLaunch( string appLaunchId, string filename);

/// 파라미터를 가지지 않는 호출하는 실행 파일에 이 통지를 등록한다.

/// 이것이 호출될 때까지, 통지는 비활성화된다.

///

/// 이것이 EXE가 아닌 DLL로부터 호출된다면, 예외가 던져진다.

/// DLL들은 다른 오버로드(overload) 중 하나를 호출하는 데에 필요하다.

/// <param name="appLaunchId">

/// 이 통지를 위한 고유한 식별자.

/// 이 ID가 이미 사용 중이라면 예외를 던진다.

/// </param>

void EnableAppLaunch( string appLaunchId );

/// 이 통지를 등록 해제한다.

/// 통지가 시작되는 것을 정지시키는 데에 이용한다.

void DisableAppLaunch();

}

/// 스케줄링 기반에서 일어나는 통지

public class ScheduledNotification : ILaunchable

{

// 이 통지의 다음 발생이 일어나도록 스케줄링 됐을 때

public DateTime NextOccurrence{ get; set; }

/// 이 통지의 발생들 간에 흐르는 시간의 양

/// 세컨드 및 밀리세컨드가 무시된다.

public TimeSpan Interval{ get; set; }

/// 발생 중에 장치가 스탠바이에 있을 때 이 통지가 동작해야하는 방법.

/// 이를 무시하고, 장치를 깨우고, 다른 무엇이 그 장치를 깨울 때까지 기다린다.

/// 디폴트 값은 Wake이다.

public StandbyBehavior StandbyBehavior{ get; set; }

/// 명명된 통지가 등록되었는지 판정

/// <param name="appLaunchId">통지의 이름</param>

/// <returns>통지가 등록되었다면 참</returns>

public static bool AppLaunchIdExists( string appLaunchId ) { }

public event EventHandler Occurred;

/// 새로운 영속적인 통지를 소정이 이름으로 생성

/// <param name="nextOccurrence">다음 발생이 일어났을 때 </param>

/// <param name="interval">발생들 간의 간격의 길이이다. 세컨드 및 밀리세컨드

///는 무시된다.</param>

public ScheduledNotification( DateTime nextOccurrence, TimeSpan interval ) { }

/// 이전에 등록된 통지에 로딩되는 형성자

/// <param name="existingAppLaunchId">이전에 등록된 통지의 이름</param>

public ScheduledNotification( string existingAppLaunchId )

{

if (!AppLaunchIdExists( name ) )

throw new ArgumentException();

}

namespace A. Mobile.Status

{

/// 새로운 값이 원하는 값과 비교되야 하는 방법을 지정하는 조건적 변경

///통지에 사용됨

public enum StateComparisonType

{

/// 이벤트는 값에 상관없이 일어난다. 이것은 디폴트임

All,

Equal,

NotEqual,

Greater,

GreaterOrEqual,

LessOrEqual,

Less,

Contains,

StartsWith,

EndsWith

}

/// 질의되고 경청될 수 있는 모든 시스템 상태를 나타내는 이늄(Enum)

public abstract class StateBase : ILaunchable

{

/// 조건적 통지를 위해, TargetValue와 새로운 값을 비교하는 방법.

public ComparisonType ComparisonType { get; set; }

/// 새로운 값과 비교될 대상. 비교가 참이면 통지만이 일어남.

public object ComparisonValue { get; set; }

/// 이 시스템 속성의 현재값

public object CurrentValue { get; }

public event ChangeNotificationEventHandler Changed;

}

/// 시스템 정의된 속성이 변경될 때 일어나는 일시적 통지

public class SystemState : StateBase

{

/// 지정된 시스템 속성의 값을 받는다.

/// <param name="property"></param>의 값을 얻을 속성

/// <returns></returns>

public static object GetValue( SystemProperty property ) { }

/// 모니터링될 시스템 속성

public SystemProperty Property { get; }

/// 명명된 통지가 등록되었는지 판정

/// <param name="appLaunchId">통지의 이름</param>

/// <returns>통지가 등록됐다면 참</returns>

public static bool AppLaunchIdExists( string appLaunchId ) { }

/// 조건문이 없는 형성자 (이벤트가 항상 일어난다)

/// <param name="property"></param>

public SystemState( SystemProperty property ) { }

/// 이벤트가 일어나야 할 때에 관한 조건을 설정하는 형성자

/// <param name="property">보여질 속성</param>

/// <param name="comparisonType">비교하는 방법</param>

/// <param name="comparisonValue">비교할 대상</param>

public SystemState( SystemProperty property, ComparisonType comparisonType, object comparisonValue ) { }

/// 이전에 등록된 통지에 로딩되는 형성자

public SystemState( string existingAppLaunchId )

{

if (!AppLaunchIdExists( name ) )

throw new ArgumentException();

}

/// 레지스트리 값이 변경평을 때 일어나는 일시적인 통지

public class RegistryValue : StateBase

{

/// 모니터링할 레지스트리 키

public RegistryKey Key { get; }

/// 모니터링할 레지스트리 키에서의 값의 이름

public string ValueName { get; }

/// 명명된 통지가 등록되었는지 판정

/// <param name="appLaunchId">통지의 이름</param>

/// <returns>통지가 등록되었다면 참</returns>

public static bool AppLaunchIdExists( string appLaunchId ) { }

/// 조건문이 없는 형성자 (이벤트가 항상 일어난다)

/// <param name="key">보여질 레지스트리 키</param>

///<param name="valueName">보여질 레지스트리 키의 레지스트리 값의

///이름</param>

public RegistryValue( RegistryKey key, string valueName ) { }

/// 이벤트가 일어나야할 때에 대한 조건문을 설정하는 형성자

/// <param name="key">보여질 레지스트리 키</param>

/// <param name="valueName">보여질 레지스트리 키의 레지스트리 값의

///이름</param>

/// <param name="comparisonType">비교할 방법</param>

/// <param name="comparisonValue">비교할 대상</param>

public RegistryValue( RegistryKey key, string valueName, ComparisonType comparisonType, object comparisonValue ) { }

/// 이전에 등록된 통지에 로딩되는 형성자.

/// <param name="existingAppLaunchId">이전에 등록된 통지 이름</param>

public RegistryValue( string existingAppLaunchId )

{

if (!AppLaunchIdExists( name ) )

throw new ArgumentException();

}

public delegate void ChangeNotificationEventHandler( object sender, ChangeNotificationEventArgs e );

public class ChangeNotificationEventArgs : EventArgs

{

public object CurrentValue { get; }

}

관리 API의 표본적인 사용

// 시스템 속성을 질의

int signal = SystemState.PhoneSignalStrength;

// 또는...

int signal = (int)SystemState.GetValue( SystemProperty.PhoneSignalStrength );

// 또는...

SystemState state = new SystemState( SystemProperty.PhoneSignalStrength );

int signal = (int)state.CurrentValue;

// 일시적인 통지에 등록

SystemState state = new SystemState( SystemProperty.PhoneSignalStrength );

state.Changed += new ChangeNotificationEventHandler( ... );

// 조건문을 가지는 영속적인 통지에 등록

SystemState state;

if( SystemState.AppLaunchIdExists( "MyApp.GoodSignal" ) )

{

state = new SystemState( "MyApp.GoodSignal" );

}

else

{

state = new SystemState( SystemProperty.PhoneSignalStrength, ComparisonType.Greater, 75 );

state.EnableAppLaunch( "MyApp.GoodSignal" );

}

state.Changed += new ChangeNotificationEventHandler( ... );

// 스케줄링된 통지에 등록

ScheduledNotification daily;

if( ScheduledNotification.AppLaunchIdExists( "MyApp.Daily" ) )

{

daily= new ScheduledNotification( "MyApp.Daily" );

}

else

{

daily = new ScheduledNotification( DateTime.Now, new TimeSpan( 24, 0, 0 ) );

daily.EnableAppLaunch( "MyApp.Daily" );

}

daily.Occurred += new EventHandler( ... );

상술한 명세서, 예시 및 데이터는 제조의 완전한 설명 및 본 발명의 조합의 사용을 제공한다. 본 발명의 다수의 실시예가 본 발명의 사상 및 범위로부터 벗어나지 않고 이루어질 수 있기 때문에, 본 발명은 특허 청구 범위에 상주한다.

도 1은 예시적인 컴퓨팅 장치를 도시함.

도 2는 예시적인 모바일 장치를 도시함.

도 3은 예시적인 상태 관리 및 통지 시스템을 도시함.

도 4는 상태 변경 통지 시스템을 위한 프로세스를 도시함.

도 5는 본 발명의 양상들에 따른, 상태 변경 정보를 프로세싱하기 위한 프로세스를 도시함.

<도면의 주요 부분에 대한 부호의 설명>

102: 프로세싱 유닛

106: 프로그램 모듈들

107: 프로그램 데이터

260: 프로세서

268: 저장 장치

310: 상태 변경 컴포넌트

315, 320: 클라이언트

335: 통지 중개자

Claims

상태 속성 변경에 응답하여 클라이언트에 통지를 제공하는 방법에 있어서,

클라이언트로부터 상태 속성에 관련된 변경에 응답하여 통지를 수신하기 위한 통지 요청을 수신하는 단계,

상기 상태 속성은 통지 시스템에 등록되는 것을 보장하는 단계 - 상기 통지 시스템은 장치 내의 상이한 컴포넌트에 의해 갱신되는 적어도 몇몇의 상태 속성을 포함함 -,

상기 상태 속성이 변경될 때를 결정하는 단계,

상기 클라이언트가 상기 상태 속성 변경의 통지를 수신해야 할 때를 결정하는 단계, 및

결정되면 상기 상태 속성 변경을 상기 클라이언트에게 통지하는 단계

를 포함하는 방법.
제1항에 있어서,

API를 사용하여 상기 상태 속성들에 관련된 행위를 수행하는 단계를 더 포함하고,

상기 행위는

상태 속성을 등록하는 단계,

상기 상태 속성을 질의하는 단계, 및

상기 상태 속성을 설정하는 단계 중 적어도 하나

를 포함하는 방법.
제2항에 있어서,

상기 클라이언트가 상기 통지를 수신해야할 때를 결정하는 단계는,

상기 상태 속성에 조건식을 적용시키는 단계, 및

상기 조건이 만족될 때 상기 상태 속성 변경을 상기 클라이언트에게 통지하는 단계

를 포함하는 방법.
제3항에 있어서,

상기 조건식은 전부, 같다, 같지 않다, 크다, 크거나 같다, 작거나 같다, 작다, 포함한다, ~로 시작한다, ~로 끝난다 라는 조건들 중 적어도 하나를 포함하는 방법.
제2항에 있어서,

상태 속성 변경 및 스케줄링된 이벤트 중 적어도 하나에 응답하여 상기 클라이언트를 런칭(launch)하는 단계를 더 포함하는 방법.
제2항에 있어서,

상기 클라이언트가 정의한 스케줄에 응답하여 상기 클라이언트에게 통지하는 단계를 더 포함하는 방법.
제2항에 있어서,

상기 상태 속성이 변경될 때를 결정하는 단계는 소정의 시간 간격 내에 일어나는 상기 상태 속성의 변경들에 대해 일괄처리 오퍼레이션을 수행하는 단계를 포함하는 방법.
제1항에 있어서,

클라이언트로부터 상기 상태 속성에 관련된 상기 변경에 응답하여 상기 통지를 수신하기 위한 통지 요청을 수신하는 단계는

상기 요청과 관련된 식별자가 상태 속성의 카테고리를 식별할 때 상기 클라이언트로부터의 상기 통지 요청과 상태 속성들의 그룹을 연관시키는 단계를 포함하고, 상기 상태 속성들은 상기 통지 시스템 내에 계층구조로 배열되는 방법.
제2항에 있어서,

상기 통지 요청을 장치의 매 재부팅마다 영속시키는 단계를 더 포함하는 방법.
상태 관리 및 통지를 위한 시스템에 있어서,

상태 속성에 관련된 정보를 저장하도록 배열된 데이터 저장 장치 - 상기 상태 속성 중 적어도 몇몇은 상이한 컴포넌트들에 의해 수정됨 -,

상기 상태 속성들에 관련된 오퍼레이션들을 수행하도록 구성된 API,

통지 요청을 등록하고 상기 통지 요청이 등록된 상태 속성의 변경에 응답하여 통지를 수신하도록 구성된 클라이언트 - 상기 통지 요청은 상기 클라이언트가 상기 상태 속성들에 관련된 변경에 응답하여 통지를 수신해야할 때를 지시함 - ,

통지 요청을 수신하도록 등록된 상기 클라이언트를 저장하도록 구성된 통지 리스트, 및

상기 데이터 저장 장치, 상기 통지 리스트, 및 상기 클라이언트에 연결된 통지 중개자를 포함하고,

상기 통지 중개자는

상기 통지 리스트에 적어도 하나의 클라이언트를 추가하라는 통지 요청을 수신하고,

상기 통지 리스트에 상기 적어도 하나의 클라이언트를 추가하고,

등록된 상태 속성이 변경될 때와 상기 상태 속성이 변경될 때를 결정하고, 통지를 수신할 상기 클라이언트를 결정하고, 상기 결정된 클라이언트에게 상기 상태 속성 변경을 통지하는 행위를 수행하도록 구성되는 애플리케이션을 포함하는 시스템.
제10항에 있어서,

상기 API는 또한

상태 속성을 등록하는 단계,

상기 상태 속성을 질의하는 단계, 및

상기 상태 속성을 설정하는 단계를 포함하는 행위 중 적어도 하나를 수행하도록 구성되는 시스템.
제11항에 있어서,

상기 통지를 수신할 상기 클라이언트를 결정하는 단계는

상기 상태 속성에 조건문을 적용시키는 단계, 및

상기 조건을 만족할 때 상기 클라이언트에게 상기 상태 속성을 통지하는 단계를 포함하는 시스템.
제12항에 있어서,

상기 조건문은 전부, 같다, 같지 않다, 크다, 크거나 같다, 작거나 같다, 작다, 포함한다, ~로 시작한다, ~로 끝난다 라는 조건들 중 적어도 하나를 포함하는 시스템.
제11항에 있어서,

상태 속성 변경 및 스케줄링된 이벤트의 적어도 하나에 응답하여 상기 클라이언트를 런칭하는 단계를 더 포함하는 시스템.
제11항에 있어서,

상기 클라이언트에 의해 정의된 스케줄에 응답하여 상기 클라이언트에게 통지하는 단계를 더 포함하는 시스템.
제11항에 있어서,

상기 상태 속성이 변경될 때를 결정하는 단계는

소정의 시간 내에 일어나는 상기 상태 속성의 변경에 대해 일괄처리 오퍼레이션을 수행하는 단계를 포함하는 시스템.
제10항에 있어서,

상기 상태 속성은 계층구조로 구성되는 시스템.
제10항에 있어서,

상기 데이터 저장 장치 내의 컨텐츠는 장치의 매 재부팅마다 영속하는 시스템.
상태 속성들에 대한 오퍼레이션을 수행하기 위한 컴퓨터 실행가능 명령어를 구비하는 컴퓨터 판독가능 매체에 있어서,

상태 파라미터들의 그룹 내에서 적어도 하나의 상태 속성을 식별하는 식별 파라미터를 수신하는 단계 - 상기 상태 파라미터들의 그룹 내의 상기 상태 파라미터들 중 몇몇은 장치 내의 상이한 컴포넌트들에 의해 갱신됨 -,

상기 상태 파라미터에 관련하여 수행되는 오퍼레이션을 결정하는 단계, 및

상기 오퍼레이션을 수행하는 단계

를 포함하는 컴퓨터 판독가능 매체.
제19항에 있어서,

상기 오퍼레이션은

상태 속성을 등록하는 오퍼레이션,

상기 상태 속성을 질의하는 오퍼레이션,

조건식을 상기 상태 파라미터와 관련시키는 오퍼레이션, 및

상기 상태 속성을 설정하는 오퍼레이션 중 적어도 하나를 포함하는 컴퓨터 판독가능 매체.
제20항에 있어서,

상기 오퍼레이션을 수행하는 단계는

상기 상태 속성에 상기 조건식을 적용하는 단계, 및

상기 조건을 만족시킬 때 상기 클라이언트에게 상기 상태 속성을 통지하는 단계를 포함하는 컴퓨터 판독가능 매체.
제21항에 있어서,

상기 조건문은 전부, 같다, 같지 않다, 크다, 크거나 같다, 작거나 같다, 작다, 포함한다, ~로 시작한다, ~로 끝난다 라는 조건들 중 적어도 하나를 포함하는 컴퓨터 판독가능 매체.
제20항에 있어서,

상기 오퍼레이션을 수행하는 단계는

상기 상태 속성의 변경 및 스케줄링된 이벤트 중 적어도 하나에 응답하여 클라이언트 애플리케이션을 런칭하는 단계를 더 포함하는 컴퓨터 판독가능 매체.
제20항에 있어서,

상기 오퍼레이션을 수행하는 단계는

상기 클라이언트가 정의한 스케줄에 응답하여 상기 클라이언트에게 통지하는 단계를 더 포함하는 컴퓨터 판독가능 매체.
제20항에 있어서,

상기 오퍼레이션을 수행하는 단계는

소정의 시간 간격 내에 일어나는 상기 상태 속성의 변경에 대해 일괄처리 오퍼레이션을 수행하는 단계를 더 포함하는 컴퓨터 판독가능 매체.