KR101476140B1 - 복수 개의 스크린 설정을 위한 멀티스크린 관리 방법 및장치 - Google Patents

복수 개의 스크린 설정을 위한 멀티스크린 관리 방법 및장치 Download PDF

Info

Publication number
KR101476140B1
KR101476140B1 KR1020070133705A KR20070133705A KR101476140B1 KR 101476140 B1 KR101476140 B1 KR 101476140B1 KR 1020070133705 A KR1020070133705 A KR 1020070133705A KR 20070133705 A KR20070133705 A KR 20070133705A KR 101476140 B1 KR101476140 B1 KR 101476140B1
Authority
KR
South Korea
Prior art keywords
screen
display
hscreen
logical
screens
Prior art date
Application number
KR1020070133705A
Other languages
English (en)
Other versions
KR20080057187A (ko
Inventor
변성욱
이광기
이종호
정운교
글렌 에이 아담스
Original Assignee
삼성전자주식회사
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 삼성전자주식회사 filed Critical 삼성전자주식회사
Publication of KR20080057187A publication Critical patent/KR20080057187A/ko
Application granted granted Critical
Publication of KR101476140B1 publication Critical patent/KR101476140B1/ko

Links

Images

Classifications

    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
    • H04N5/00—Details of television systems
    • H04N5/44—Receiver circuitry for the reception of television signals according to analogue transmission standards
    • H04N5/445—Receiver circuitry for the reception of television signals according to analogue transmission standards for displaying additional information
    • H04N5/45—Picture in picture, e.g. displaying simultaneously another television channel in a region of the screen
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
    • H04N21/00—Selective content distribution, e.g. interactive television or video on demand [VOD]
    • H04N21/40—Client devices specifically adapted for the reception of or interaction with content, e.g. set-top-box [STB]; Operations thereof
    • H04N21/43—Processing of content or additional data, e.g. demultiplexing additional data from a digital video stream; Elementary client operations, e.g. monitoring of home network or synchronising decoder's clock; Client middleware
    • H04N21/431—Generation of visual interfaces for content selection or interaction; Content or additional data rendering
    • H04N21/4312—Generation of visual interfaces for content selection or interaction; Content or additional data rendering involving specific graphical features, e.g. screen layout, special fonts or colors, blinking icons, highlights or animations
    • H04N21/4316—Generation of visual interfaces for content selection or interaction; Content or additional data rendering involving specific graphical features, e.g. screen layout, special fonts or colors, blinking icons, highlights or animations for displaying supplemental content in a region of the screen, e.g. an advertisement in a separate window
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
    • H04N21/00—Selective content distribution, e.g. interactive television or video on demand [VOD]
    • H04N21/40—Client devices specifically adapted for the reception of or interaction with content, e.g. set-top-box [STB]; Operations thereof
    • H04N21/43—Processing of content or additional data, e.g. demultiplexing additional data from a digital video stream; Elementary client operations, e.g. monitoring of home network or synchronising decoder's clock; Client middleware
    • H04N21/443—OS processes, e.g. booting an STB, implementing a Java virtual machine in an STB or power management in an STB
    • H04N21/4433—Implementing client middleware, e.g. Multimedia Home Platform [MHP]
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
    • H04N21/00—Selective content distribution, e.g. interactive television or video on demand [VOD]
    • H04N21/40—Client devices specifically adapted for the reception of or interaction with content, e.g. set-top-box [STB]; Operations thereof
    • H04N21/45—Management operations performed by the client for facilitating the reception of or the interaction with the content or administrating data related to the end-user or to the client device itself, e.g. learning user preferences for recommending movies, resolving scheduling conflicts
    • H04N21/462—Content or additional data management, e.g. creating a master electronic program guide from data received from the Internet and a Head-end, controlling the complexity of a video stream by scaling the resolution or bit-rate based on the client capabilities
    • H04N21/4622—Retrieving content or additional data from different sources, e.g. from a broadcast channel and the Internet
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04N—PICTORIAL COMMUNICATION, e.g. TELEVISION
    • H04N21/00—Selective content distribution, e.g. interactive television or video on demand [VOD]
    • H04N21/40—Client devices specifically adapted for the reception of or interaction with content, e.g. set-top-box [STB]; Operations thereof
    • H04N21/43—Processing of content or additional data, e.g. demultiplexing additional data from a digital video stream; Elementary client operations, e.g. monitoring of home network or synchronising decoder's clock; Client middleware
    • H04N21/436—Interfacing a local distribution network, e.g. communicating with another STB or one or more peripheral devices inside the home
    • H04N21/43615—Interfacing a Home Network, e.g. for connecting the client to a plurality of peripherals

Landscapes

  • Engineering & Computer Science (AREA)
  • Multimedia (AREA)
  • Signal Processing (AREA)
  • Databases & Information Systems (AREA)
  • Software Systems (AREA)
  • Business, Economics & Management (AREA)
  • Marketing (AREA)
  • Two-Way Televisions, Distribution Of Moving Picture Or The Like (AREA)
  • Controls And Circuits For Display Device (AREA)
  • Studio Circuits (AREA)
  • User Interface Of Digital Computer (AREA)

Abstract

본 발명은, 복수 개의 서비스 컨텐츠들을 표현하기 위해 다수의 스크린을 사용하여 다양한 방식으로 스크린 간의 설정 및 그 스크린들을 관리하기 위함이다.
본 발명의 일 실시예에 따른 멀티스크린 설정 매니지먼트 방법은 적어도 하나 이상의 방송 서비스, 적어도 하나 이상의 로지컬 스크린, 적어도 하나 이상의 디스플레이 스크린 및 적어도 하나 이상의 출력 포트를 상호 지정하여, 출력 포트에 지정된 스크린에서 실행되는 서비스 컨텐츠를 최종 출력하고, 멀티스크린 설정을 생성, 변경, 보고함으로써, 다양한 서비스 컨텐츠를 스크린 상에 원하는 방식으로 효과적으로 출력하는 멀티스크린 설정을 구성하고 재설정할 수 있다.
멀티플 스크린, 멀티스크린 설정, 멀티스크린 매니지먼트, OCAP

Description

복수 개의 스크린 설정을 위한 멀티스크린 관리 방법 및 장치{Method and apparatus for multiscreen management for multiple screen configuration}
본 발명은 복수 개의 서비스가 표시되는 스크린을 구성하는 방법 및 장치에 관한 것으로, 상세하게는 복수 개의 서비스가 재생되거나 표시되는 복수 개의 스크린을 포함하는 최종 출력 스크린을 구성하는 방법 및 장치에 관한 것이다.
디지털 TV, 디지털 셋탑 박스 등의 현존 방송 수신 시스템에서는 일반적으로, 한 디스플레이에 한 서비스 컨텐츠만 표시되거나, 한 디스플레이에 주화면과 부화면의 두 가지 화면이 동시에 표시된다. 주화면과 부화면이 동시에 표시된다 하더라도 방송 수신 시스템에서 제한된 기정 형식으로만 디스플레이 배치될 수 있다. 또한, 방송 서비스, DVD 입력, 외부 입력 소스 등의 여러 소스로부터의 서비스들이 조합되어 표시될 수 있는 디스플레이의 종류도 제한되어 있다. 주화면에서 비디오 서비스, 오디오 서비스, 데이터 서비스가 모두 표시될 수 있더라도, 부화면에서는 데이터 서비스가 표시될 수 없다.
도 1 은 종래 기술에 따라 PiP 방식으로 구현된 화면 구성 형태를 도시한다.
기존의 픽처-인-픽처(Picture-in-Picture, 이하 'PiP'라 함.) 방식은 물리적 인 디스플레이 스크린 상에 주 스크린과 부 스크린이 함께 표시된다. 스크린 100, 110, 120, 130, 140 및 150은 물리적인 디스플레이 스크린들이며, 스크린 105, 115, 125, 135, 142, 144, 152 및 154 는 부 스크린에 해당한다. 특히 부 스크린 105, 115, 125, 135, 142, 144, 152, 154는 그 위치 또는 사이즈가 제한되어 있어, PiP 방식을 유연하게 구현하는데 한계가 있다.
MHP(Multimedia Home Platform)/ACAP(Application Configuration Access Protocol)/OCAP(OpenCable Application platform) 등과 같은 인터랙티브 TV(Interactive TV) 응용 프로그램 환경에서, 일반적으로 출력 스크린이 하나라고 가정된다. 인터랙티브 TV 응용 프로그램 환경은 HAVi 사용자 인터페이스(Home Audio-Visual interface User Interface) 구조를 채용한다. HAVi 사용자 인터페이스는 화면 수에 제한이 있지는 않으나, 실제 사용하는 측면에 있어서는 일반적으로 하나의 출력 스크린을 사용한다. 또한 응용 프로그램이 하나의 출력 화면을 공유하여 실행된다.
따라서, 기존의 방송 서비스를 위한 응용 프로그램 환경은 스크린 상에서 여러 종류의 서비스 컨텐츠들을 다양한 방식으로 재생하는데 한계가 있다.
본 발명이 해결하고자 하는 과제는, 복수 개의 서비스 컨텐츠들이 동시에 한 스크린 상에서 스크린의 위치, 크기 등 원하는 방식으로 표현될 수 있는 멀티스크린 설정 및 이러한 멀티스크린 설정을 관리하는 방법 및 장치를 제안하는데 있다.
또한, 멀티스크린을 지원하는 디바이스의 리소스를 효과적으로 사용하도록 하는 인터페이스가 제안되며, 멀티스크린 기능성을 관리하기 위해 호환 가능한 어플리케이션이 제안된다. 뿐만 아니라, 멀티스크린 기능성 및 PiP, PoP 화면과 같은 멀티스크린 상태를 관리 및 설정하기 위한 표준화된 인터페이스가 제안된다.
본 발명의 멀티스크린 관리 방법 및 장치는 서비스 컨텐츠들을 복수 개의 독립적인 로지컬 스크린에 보여주기 위해, 동적으로 응용 프로그램의 라이프사이클(lifecycle)과 리소스 사용을 각각의 스크린마다 통제한다.
본 발명의 일 실시예에 따른 멀티스크린 설정 매니지먼트 방법은 적어도 하나 이상의 방송 서비스를 수신받는 단계, 스크린에 적어도 하나 이상의 상기 방송 서비스를 지정하는 단계, 상기 스크린을 적어도 하나 이상의 디스플레이 스크린에 지정하는 단계, 상기 적어도 하나 이상의 디스플레이 스크린을 적어도 하나 이상의 출력 포트에 지정하는 단계를 포함한다.
일 실시예는, 상기 로지컬 스크린에 대한 서비스 컨텍스트 및 상기 디스플레이 스크린에 대한 컨텍스트를 연관짓는 단계, 상기 컨텍스트의 연관 관계를 변경하 는 단계를 포함한다.
일 실시예는, 상기 로지컬 스크린, 상기 디스플레이 스크린, 상기 서비스에 대한 컨텍스트, 상기 출력 포트에 대한 제반 정보를 포함하는 멀티스크린 설정을 결정하는 단계, 상기 멀티스크린 설정을 변경하는 단계를 포함한다.
일 실시예는, 상기 멀티스크린 설정의 변경을 위한 전제 조건 및 사후 조건을 준수하는 단계를 포함한다.
일 실시예는, 상기 멀티스크린 설정의 변경, 상기 컨텍스트들의 변경을 보고하는 단계를 포함한다.
본 발명의 멀티스크린 설정 및 멀티스크린 매니지먼트 방법 및 장치는, 적어도 하나 이상의 서비스 컨텐츠를 적어도 하나 이상의 스크린에 일대일 대응이 아닌 다(多)대다(多)로 대응함으로써, 원하는 방식으로 스크린을 구성하여 최종 출력할 수 있다. 또한, 다양한 리소스 관리 인터페이스에 의해 멀티스크린 매니지먼트 기능성은 멀티스크린을 지원하는 호스트 디바이스의 리소스를 효과적으로 사용할 수 있다.
본 발명의 일 실시예에 따른 OCAP MSM 익스텐션은 어플리케이션 레벨에 이르기까지 모든 필요한 어플리케이션 프로그램 인터페이스, 즉 API(application program interface), 컨텐츠 및 데이터 형식, 프로토콜들의 확장형이다. OCAP MSM 익스텐션으로 개발된 어플리케이션은 Opencable 기반의 호스트 디바이스 상에서 실행될 수 있다. OCAP MSM 익스텐션에서는, 케이블 운영자가, 그들의 네트워크에 관 련된 OpenCable 기반의 호스트 디바이스 상에서 멀티스크린 기능성을 관리하기 위해 호환 가능한 어플리케이션을 배치하도록 한다. 본 프로파일에서는, 케이블 운영자가, 복수의 호스트 디바이스 제공 업체들 간에, 멀티스크린 기능성 및 PiP 및 PoP 화면과 같은 멀티스크린 상태를 관리하기 위한 표준화된 인터페이스를 보유할 수 있다.
본 발명의 일 실시예에 따른 OCAP MSM 익스텐션은, 가전 제품 제조업체들이 유연하게 구현할 수 있는 매우 다양한 하드웨어 및 운영 시스템에 응용될 수 있다. OCAP MSM 익스텐션으로 인해, 가전제품 제조업체들이, 멀티스크린 기능성을 인식하기 원하는 케이블 네트워크에 독립적인 어플리케이션 뿐만 아니라 케이블 운영자에 의해 정의된 어플리케이션에 의해 사용되기 위한 일관적이고 호환 가능한 프로그램의 인터페이스를 지원하면서 경쟁적으로 구현할 수 있다.
이하, 도 2 내지 34c 를 참고하여, 본 발명의 멀티스크린 매니지먼트에 대해 상술된다.
도 2 내지 10을 참고하여, 본 발명에서 도입되는 멀티스크린 시스템 및 멀티스크린 매니지먼트의 개략적 개념이 상술된다.
도 11a 내지 29를 참고하여, 본 발명의 일 실시예가 자바 타입으로 구현된 경우 각종 자바 타입의 정의 및 함수들이 상술된다.
도 30a 내지 34c를 참고하여, 본 발명의 일 실시예가 OCAP 환경에서 구현되기 위해 기존 OCAP 표준 규격으로부터 변경 또는 추가되어야 하는 개념들이 상술된 다.
이하 본 명세서의 설명의 편의를 위해, 약어 및 용어에 대해 미리 정의한다.
'HAVi'는 '홈 오디오-비주얼 인터페이스(Home Audio-Visual Interface)'의 약어이며, 'MSM'는 '멀티스크린 매니저(Multiscreen Manager)'의 약어이다. 'PiP'는 '픽처-인-픽처(Picture-in-picture)'의 약어이며, 'PoP'는 '픽처-아웃사이드-픽처(Picture-outside-picture)'의 약어이다. 'AIT'는 '어플리케이션 정보 테이블(Application Information Table)'의 약어이며, 'XAIT'는 '익스텐디드 어플리케이션 정보 테이블(Extended Application Information Table)'의 약어이다.
'오디오 포커스 스크린(Audio Focus Screen)'이란 가능한 비디오 출력 포트에 연관된 모든 오디오 재생 디바이스 중에서 연주되도록 선택되는 오디오 소스에 연관된 스크린을 뜻한다. 이 때, 해당 오디오 포커스 스크린이 디스플레이 스크린이라면 비디오 출력 포트는 오디오 포커스 스크린과 직접적으로 연관되며, 해당 오디오 포커스 스크린이 맵핑된 로지컬 스크린이라면 비디오 출력 포트는 오디오 포커스 스크린과 간접적으로 연관된다.
'디스플레이 맵퍼(Display Mapper)'는 로지컬 스크린의 정규화된 좌표 공간을 디스플레이 스크린의 정규화된 좌표 공간 (또는 그 일부분)에 배치하는 논리적 처리 과정을 뜻한다.
'디스플레이 멀티스크린 설정(Display Multiscreen Configuration)'은 디스플레이 스크린만으로 설정된 멀티스크린 설정을 의미한다. 모든 플랫폼별 멀티스크 린 설정은 디스플레이 멀티스크린 설정이다. 디스플레이 멀티스크린 설정의 설정 타입은 후술될 'SCREEN_CONFIGURATION_DISPLAY'이다.
'디스플레이 스크린(Display Screen)'은 출력을 위한 물리적인 디스플레이 디바이스의 최종 조합을 나타내기 위한 스크린 타입을 뜻한다. 디스플레이 스크린은 하나 이상의 비디오 출력 포트와 연관된다. 여기서 비디오 출력 포트는, (ⅰ) 내부적으로 통합된 디스플레이에 부착된 비디오 출력 포트, 또는 (ⅱ) 예를 들어 HDMI(High Definition Multimedia Interface), IEEE 1394(Institute of Electrical and Electronics Engineers 1394) 등의 일부 정의가 명확한 인터페이스를 통해 외부의 디스플레이 디바이스에 연관될 수 있는 물리적 출력 포트 케이블에 부착된 비디오 출력 포트 중 적어도 어느 하나이다.
'일반 스크린(General Screen)'은 후술될 'general screen 카테고리'에 지정된 로지컬 스크린이다. 일반 스크린은 일반적으로 재설정될 수 있어 다른 응용 케이스를 지원할 수 있다. 예를 들어, 어떤 경우에는 일반 스크린이 PiP 스크린로 설정될 수 있으며, 다른 경우에는 PoP 스크린로 설정될 수도 있다.
'로지컬 스크린(Logical Screen)'은 디스플레이 디바이스에 직접적으로 연관되지 않으며, 디스플레이 맵핑 처리 과정을 통해 디스플레이 스크린에 맵핑될 수 있다. 로지컬 스크린은 맵핑될 수도 있으며, 맵핑되지 않을 수도 있다. 만약 맵핑된다면, 로지컬 스크린은 디스플레이 스크린에 연관된다. 맵핑되지 않는다면, 디스플레이 스크린에 연관되지 않는다. 예외적인 경우로, 로지컬 스크린은 비디오 출력 포트에 직접적으로 연관되어, 로지컬 스크린의 역할 및 준 디스플레이 스크린의 역 할을 동시에 수행한다.
'메인 스크린(Main Screen)'은 후술될 'main screen 카테고리'에 지정된 디스플레이 스크린 또는 로지컬 스크린을 뜻한다. 메인 스크린은, (MSM의 인식 없이 디스플레이 디바이스 자체에 의해 더 이상 맵핑되지 않는다면,) 항상 디스플레이 디바이스의 전체 스크린 범위와 동일한 공간에 정의된다.
'멀티스크린 설정 가능 컨텍스트(Multiscreen Configurable Context)'은 멀티스크린 매니지먼트 기능성에 연관된 상태 정보를 설정 (또는 변경)하는 기능을 제공하는 멀티스크린 컨텍스트의 확장형이다. 멀티스크린 설정 가능 컨텍스트는, 후술될 본 발명의 일 실시예에서 사용되는 'MultiScreenConfigurableContext' 인터페이스에 의해 정의되며, 본 명세서 상에서 'MultiScreenConfigurableContext'는 멀티스크린 설정 가능 컨텍스트를 나타내기 위한 자바 타입이다.
'멀티스크린 설정(Multiscreen Configuration)'은 컨텐츠를 재생하거나 재생할 수 있는 식별 가능한 스크린들의 집합을 뜻하며, 이 식별 가능한 스크린들의 집합은 소정 플랫폼 구현 상 또는 소정의 디스플레이 스크린 상의 모든 억세스 가능한 스크린들의 적합한 하위 집합일 수 있다. 어떤 경우에라도, 단일 멀티스크린 설정이 (ⅰ) 플랫폼 전체에 적용되는 경우 멀티스크린 설정 내의 스크린들은 모두 디스플레이 스크린이며, (ⅱ) 각각의 디스플레이 스크린에 적용되는 경우 멀티스크린 설정 내의 스크린들은 디스플레이 스크린 그 자체이거나 디스플레이 스크린에 맵핑되는 로지컬 스크린들이다. 하나의 상기 스크린은 다수의 멀티스크린 설정에 동시에 존재할 수 있다.
멀티스크린 설정은 후술될 본 발명의 일 실시예에서 사용되는 'MultiScreenConfiguration' 인터페이스에서 정의되며, 본 명세서 상에서 'MultiScreenConfiguration'는 상기 멀티스크린 설정을 나타내기 위한 자바 타입이다.
'멀티스크린 설정 타입(Multiscreen Configuration Type)'은 주로 그 설정하는 스크린 카테고리에 기초하는 멀티스크린 구조의 특성을 나타낸다. 멀티스크린 설정 타입들은 (ⅰ) 디스플레이 멀티스크린 설정으로 알려진 싱글턴(singleton) 디스플레이 멀티스크린 설정 타입, 및 (ⅱ) 넌-디스플레이(Non-display) 멀티스크린 설정으로 알려진 모든 다른 멀티스크린 설정 타입들로 더 세부적으로 분류된다.
'멀티스크린 컨텍스트(multiscreen context)'는 복수 개의 스크린을 구현하는 플랫폼 상에서 호환을 가능하게 하기 위해 HAVi 스크린을 확장하는 상태 정보들의 집합을 의미한다. 기본적인 멀티스크린 컨텍스트는 이런 상태 정보를 검색하는 기능성을 제공한다. 일 실시예에서, 기본적인 멀티스크린 컨텍스트는 이런 상태 정보들을 변경하지 않은 채 검색한다.
멀티스크린 컨텍스트는 후술될 본 발명의 일 실시예에서 사용되는 'MultiScreenContext' 인터페이스에서 정의되며, 본 명세서 상에서 'MultiScreenContext'는 상기 멀티스크린 컨텍스트를 나타낸다.
'멀티스크린 매니저(Multiscreen Manager)'는, 본 명세서에서 정의되는 특징들을 통해, 복수 개의 스크린들을 효과적으로 사용할 수 있도록 하는 플랫폼 구현에 의해 제공되는 싱글턴 매니지먼트 컴포넌트를 의미한다. 또한, 멀티스크린 매니 저는 '멀티플 스크린 매니저(multiple screen manager)'라고 지칭된다.
멀티스크린 매니저는 후술될 본 발명의 일 실시예에서 사용되는 'MultiScreenManager' 클래스에서 정의되며, 본 명세서 상에서 'MultiScreenManager'는 상기 멀티스크린 매니저를 나타내는 자바 타입이다.
'오버레이 스크린(Overlay Screen)'은 후술될 'Overlay screen 카테고리'에 지정된 로지컬 스크린을 의미한다. 오버레이 스크린의 z-order는 해당 오버레이 스크린을 모든 다른 넌(non)-오버레이 스크린이 비해 가장 앞쪽에 위치시킨다.
'디스플레이별 멀티스크린 설정(per-display multiscreen configuration)'은 주어진 디스플레이 스크린과 연관된 활성화된 스크린들 또는 잠재적인 활성 스크린들을 정의하거나 정의하기 위해 사용될 수 있는 넌(non)-디스플레이 멀티스크린 설정을 의미한다. 현재 활성화된인 플랫폼별 멀티스크린 설정 중 각각의 기저 디스플레이 스크린은, 현재 활성화된 플랫폼별 멀티스크린 설정 중 활성화된 디스플레이별 멀티스크린 설정을 정의하는 상태 변수를 포함한다.
'플랫폼별 멀티스크린 설정(per-platform multiscreen configuration)'은 활성 디스플레이 스크린들 또는 잠재적인 활성 디스플레이 스크린들을 현재 정의하거나 정의하기 위해 사용될 수 있는 디스플레이 멀티스크린 설정을 의미한다. 현재 활성화된 플랫폼별 멀티스크린 설정은 멀티스크린 매니저 싱글턴 인스턴스의 상태 변수이다.
'PiP 스크린(PiP screen)'은 'PiP screen 카테고리'에 지정된 로지컬 스크린을 의미한다. PiP 스크린은 일반적으로 메인 스크린과 교차하며, 메인 스크린보다 z-order 상으로 더 앞에 배치된다.
'PoP 스크린(PoP screen)'은 'PoP screen 카테고리'에 지정된 로지컬 스크린을 의미한다. PiP 스크린은 일반적으로 하나 이상의 다른 PoP 스크린들과 함께 배열되어 디스플레이 스크린의 영역을 채운다.
'스크린(screen)'은 배경 색상, 배경 이미지, 비디오 및 그래픽들의 일부 조합을 재생할 수 있는 리소스들을 의미한다. 상기 배경 색상, 배경 이미지, 비디오 및 그래픽은 HAVi에서 제공하는 '스크린 디바이스(HScreenDevice)'를 통해 표현되며, 배경 색상, 배경이미지는 '백그라운드 디바이스(HBackgroundDevice)', 비디오는 '비디오 디바이스(HVideoDevice)', 그래픽은 '그래픽 디바이스(HGraphicDevice)'로 나타낼 수 있다. 스크린은 각 스크린 디바이스들을 디폴트로 'HBackgroundDevice', 'HVideoDevice', 'HGraphicDevice' 각 한 개씩을 포함할 수 있다. 스크린은 디스플레이 스크린 및 로지컬 스크린 중 어느 하나로 분류된다.
'디폴트 스크린'은 복수 개의 스크린 중 가장 접근성이 좋은, 즉 가장 접근하기 쉬운 스크린을 의미하며, '디폴트 스크린 디바이스'는 복수 개의 스크린 디바이스 중 가장 접근하기 쉬운 스크린 디바이스를 의미한다. 상기 스크린 디바이스는 백그라운드 디바이스, 비디오 디바이스, 그래픽 디바이스 중 하나일 수 있다.
'스크린 카테고리(Screen Category)'는 스크린의 사용 용도 또는 설정가능성 특성에 따른 스크린들의 분류를 나타낸다.
'스크린 식별자(Screen identifier)'는 기저 스크린과 그 스크린에 할당된 리스스들에 대한 플랫폼 상 고유 지정자을 나타낸다. 또한, '스크린 식별자'는 다 른 카테고리의 스크린들 사이 또는 동일 카테고리의 스크린들 사이의 구별을 가능하게 하기 위해, 기저 스크린의 플랫폼 상 고유 지정을 나타낸다.
'스크린 타입(screen type)'은 스크린들을 디스플레이 스크린 및 로지컬 스크린의 두 가지 타입으로 분류하는 상위 레벨 분류를 의미한다.
'서비스(service)'는 다수의 서비스 컴포넌트(service component)들을 포함하는 멀티미디어 컨텐츠이다.
'서비스 컴포넌트(service component)'는 비디오 컴포넌트, 오디오 컴포넌트, 데이터 컴포넌트 등을 포함하는 서비스의 구성 요소이다. 데이터 컴포넌트는 플랫폼 상에서 실행되는 어플리케이션 및 서비스를 위한 다양한 정보들을 포함한다.
'서비스 컨텍스트(service context)'는 실행될 서비스에 대한 리소스들, 디바이스들, 상태 정보 등을 포함하는 객체를 나타낸다.
'OCAP 멀티스크린 매니저(multiscreen manager, MSM) 익스텐션'은 멀티스크린에 대한 특성들을 지원하는 플랫폼 구현 내의 복수 개의 디스플레이 스크린 및 복수 개의 로지컬 스크린을 효과적으로 사용하게 하는 기능성 및 동작들의 집합을 정의한다.
'멀티스크린 설정 리스너'(multiscreen configuration listener)는 멀티스크린 매니저의 총체적 상태 또는 플랫폼별 또는 일부 디스플레이별 멀티스크린 설정 각각에 관한 일부 디스플레이 스크린의 상태로 시스템 및 어플리케이션이 발생시킨 변경, 또는 소정 멀티스크린 설정으로의 변경들에 관한 통지를 제공하기 위해 사용 된다. 멀티스크린 설정 리스너는 후술될 본 발명의 일 실시예의 'MultiScreenConfigurationListener' 인터페이스에서 정의되며, 본 명세서 상에서 'MultiScreenConfigurationListener'은 멀티스크린 설정 리스너를 나타내기 위한 자바 타입이다.
'멀티스크린 컨텍스트 리스너'(multixcreen context listener)는 시스템 및 어플리케이션이 멀티스크린 컨텍스트의 변경을 발생시킨 경우, 상기 변경에 관한 통지를 제공하기 위해 사용된다. 멀티스크린 컨텍스트 리스너는 후술될 본 발명의 일 실시예의 'MultiScreenContextListener' 인터페이스에서 정의되며, 본 명세서 상에서 'MultiScreenContextListener'은 멀티스크린 컨텍스트 리스너를 나타내기 위한 자바 타입이다.
'멀티스크린 설정 이벤트'(multiscreen configuration event)는 멀티스크린 매니저의 총체적 상태 또는 플랫폼별 또는 일부 디스플레이별 멀티스크린 설정 각각에 관한 일부 디스플레이 스크린의 상태로 변경, 또는 소정 멀티스크린 설정으로의 변경들에 관한 보고하기 위해 사용된다. 멀티스크린 설정 이벤트는 후술될 본 발명의 일 실시예의 'MultiScreenConfigurationEvent' 인터페이스에서 정의되며, 본 명세서 상에서 'MultiScreenConfigurationEvent'은 멀티스크린 설정 이벤트를 나타내기 위한 자바 타입이다.
'멀티스크린 컨텍스트 이벤트'(multiscreen context event)는 멀티스크린 컨텍스트의 변경을 관심있는 리스너들로 보고하기 위해 사용된다. 멀티스크린 컨텍스트 이벤트는 후술될 본 발명의 일 실시예의 'MultiScreenContextEvent' 인터페이스 에서 정의되며, 본 명세서 상에서 'MultiScreenContextEvent'은 멀티스크린 컨텍스트 이벤트를 나타내기 위한 자바 타입이다.
'멀티스크린 이벤트'(multiscreen event)는 멀티플 스크린 매니지먼트 기능성과 관련된 다른 종류의 타입들의 이벤트들의 의해 사용되는 이벤트 식별 코드들을 설정하기 위해 사용되는 추상적인 기본 개념 용어이다. 멀티스크린 이벤트는 후술될 본 발명의 일 실시예의 'MultiScreenEvent' 인터페이스에서 정의되며, 본 명세서 상에서 'MultiScreenEvent'은 멀티스크린 이벤트를 나타내기 위한 자바 타입이다.
'멀티스크린 리소스 이벤트'(multiscreen resource event)는 멀티스크린 관련 리소스들의 리소스 상태에 관한 변경들을 보고하기 위해 사용된다. 멀티스크린 리소스 이벤트는 후술될 본 발명의 일 실시예의 'MultiScreenResourceEvent' 인터페이스에서 정의되며, 본 명세서 상에서 'MultiScreenResourceEvent'은 멀티스크린 리소스 이벤트를 나타내기 위한 자바 타입이다.
세부적인 플랫폼 구현이 본 확장형을 지원하는 범위는 플랫폼 및 디바이스 제작자, 또는 본 익스텐션의 다른 외부 프로파일에 의해 결정된다. 또한, 세부적인 플랫폼 구현이 본 OCAP MSM 익스텐션을 지원하는 범위는, 사용가능한 튜너 또는 독립적인 입력 소스들의 개수, 사용가능한 비디오 디코딩 파이프라인의 개수, 통합 디스플레이의 개수, 독립적인 비디오 (및 오디오) 출력 포트의 개수, 비디오 및 그래픽 버퍼링을 위해 사용가능한 메모리 양, 및 다른 명시되지 않은 리소스들을 포함하는 하드웨어의 종류 및 설정가능성에 대한 일반적인 기술로 포함된다.
이하, 도 2 내지 10을 참고하여, 본 발명에서 도입되는 멀티스크린 시스템 및 멀티스크린 매니지먼트의 개략적 개념이 상술된다.
도 2 는 본 발명의 일 실시예에 따른 로지컬 스크린, 디스플레이 스크린 및 디스플레이 맵퍼의 관계를 도시한다.
멀티스크린 매니지먼트 상의 스크린은, 하나 이상의 로지컬 스크린 집합(210) 및 하나 이상의 디스플레이 스크린 세트(230)를 포함한다. 로지컬 스크린 집합(210)은 디스플레이 맵퍼(220)를 통해 디스플레이 스크린 세트(230)에 연관된다. 디스플레이 맵퍼(220)는 로지컬 스크린의 정규화된 좌표 공간을 디스플레이 스크린의 정규화된 좌표 공간의 영역에 합성하는 논리적 처리과정이다. 즉, 디스플레이 맵퍼(220)를 통해 하나의 디스플레이 화면에 하나 이상의 로지컬 스크린들이 원하는 위치에 연관되어 표시될 수 있다.
예를 들어, 본 발명의 일 실시예에 따른 멀티스크린 매니지먼트 시스템에, 디스플레이 맵퍼(220), 복수 개의 로지컬 스크린들(212, 214, 216) 및 복수 개의 디스플레이 스크린들(240, 250, 260)이 존재한다. 디스플레이 맵퍼(220)에 의해, 로지컬 스크린 212, 214 및 216 중 적어도 하나가 각각의 디스플레이 스크린(240, 250, 260) 상에 표시된다.
즉, 디스플레이 맵퍼(220)에 의해, 디스플레이 스크린 240 내에 로지컬 스크린이 표시된 영역 242 및 244가 나란히 배치되며 배열될 수 있으며, 로지컬 스크린 212가 축소되어 스크린 영역 242에 배치되며, 로지컬 스크린 214도 역시 크기 조절 되어 스크린 영역 244에 배치된다. 이와 마찬가지로, 디스플레이 스크린 250은 로지컬 스크린 214가 가장 뒤쪽으로 배치된 스크린(252)이며, 로지컬 스크린(254)은 디스플레이 스크린의 스크린 영역의 일부분(254)에 배치된다. 또한, 디스플레이 스크린 260에는 로지컬 스크린 212가 가장 뒤쪽으로 배치되는 스크린 영역(262)에 배치되며, 로지컬 스크린 214가 디스플레이 스크린 260 상에 배치되며, 로지컬 스크린 214가 축소되어 디스플레이 스크린의 일부 영역 264에 배치되고, 로지컬 스크린 216이 축소되어 디스플레이 스크린의 일부 영역 266에 배치된다.
도 3 은 본 발명의 일 실시예에 따른 멀티스크린 매니저를 구현할 수 있는 디지털 TV 시스템의 블록도를 도시한다.
디지털 TV 시스템(300)이 방송 신호 수신부(310), 디지털 신호 처리부(320), 멀티미디어 서비스 처리부(330), 출력부(340) 및 디스플레이(350)를 포함한다.
방송 신호 수신부(310)는 케이블 방송 신호를 수신한다. 다른 실시예의 방송 신호 수신부는 지상파 방송 신호 또는 위성 방송 신호를 수신할 수도 있다.
디지털 신호 처리부(320)는, 방송 신호 수신부(310)에서 수신된 서비스 컴포넌트를 이용하여 서비스를 재구성한다.
멀티미디어 신호 처리부(330)는, 디지털 신호 처리부(320)에 의해 재구성된 서비스를 표현하기 위한 로지컬 스크린을 생성하여 출력부(340)로 출력한다.
출력부(340)는 디스플레이 스크린을 생성하고, 디스플레이 스크린과 로지컬 스크린을 맵핑시킨다. 즉, 로지컬 스크린을 디스플레이 스크린에 연관시켜, 로지컬 스크린의 서비스가 디스플레이 스크린에 연관되도록 한다. 본 발명의 일 실시예는, 서비스는 로지컬 스크린에 연관된 후 디스플레이 스크린에 연관되는 경우뿐만 아니라, 서비스가 직접적으로 디스플레이 스크린에 연관되는 경우도 포함된다.
또한, 출력부(340)의 일 실시예가 하나 이상의 출력 포트를 포함하는 경우, 디스플레이 스크린과 출력 포트가 연관될 수 있다.
디지털 TV 시스템(300)이 멀티스크린 매니지먼트 기능성을 구현하기 위해서, 멀티미디어 신호 처리부(330) 및 출력부(340)에서, 로지컬 스크린, 디스플레이 스크린 및 출력 포트 사이의 연관 관계가 결정되어야 한다. 일 실시예에서, 다수의 스크린 생성은 플랫폼 구현시 이루어지며, 멀티스크린 매니지먼트 기능성의 구현, 즉 멀티스크린의 설정, 관리 및 설정의 변경은 후술되는 멀티스크린 매니저(MSM)을 위한 API를 제공한다.
디스플레이부(350)는, 디스플레이 스크린이 표시되는 물리적인 디스플레이 화면 장치를 포함한다.
도 4 는 본 발명의 일 실시예를 구현하는 디지털 TV 시스템에서 여러 컨텐츠를 재생하는 일례를 도시한다.
일 실시예에 따른 디지털 TV 시스템(400)는, 지상파 방송 컨텐츠(410), 케이블 방송 컨텐츠(420) 및 PVR(Personal Video Recoder) 데이터 컨텐츠(430)가 동시에 재생될 수 있다. 즉, DTV/STB 모듈(Digital TV Settop Box Module)에서 본 발명의 멀티스크린 매니지먼트가 구현될 수 있다면, 지상파 방송 컨텐츠(410), 케이블 방송 컨텐츠(420) 및 PVR 데이터 컨텐츠(430)이 각각 로지컬 스크린에 연관되어, 각각의 로지컬 스크린은 디스플레이 스크린(450) 상에서 표현된다.
본 발명의 멀티스크린 매니지먼트는 하나 이상의 로지컬 스크린과 하나 이상의 디스플레이 스크린 사이의 연관 관계를 정의하므로, 하나 이상의 로지컬 스크린이 하나의 디스플레이 스크린에 맵핑될 수 있다. 즉, 지상파 방송 컨텐츠(410)의 로지컬 스크린이 디스플레이 스크린(450) 상의 스크린 영역 452에 배치되고, 케이블 방송 컨텐츠(420)의 로지컬 스크린은 디스플레이 스크린(450) 상의 일부 스크린 영역 456에 배치된다. 또한, DTV/STB 모듈에 의해, PVR 컨텐츠(430)의 로지컬 스크린이 디스플레이 화면(450)의 일부 스크린 영역 454에 배치된다.
즉, 디스플레이 스크린 450은 로지컬 스크린들 452, 454, 456이 소정 순서에 따라 다양한 위치 및 다양한 크기로 배치될 수 있다.
도 5a 및 5b 는 각각 비추상 서비스 및 추상 서비스의 개념 및 일례를 도시한다.
도 5a의 서비스 집합 510은 비추상 서비스 집합이며, 도 5b의 서비스 집한 550은 추상 서비스 집합이다. 비추상 서비스 집합 510은 비디오 서비스(520), 오디오 서비스(530) 및 어플리케이션 서비스(540)을 포함하는 서비스 집합이다. 이에 반해, 추상 서비스 집합 550은 비디오 어플리케이션(560), 오디오 어플리케이션(570)를 포함한다. 즉, 추상 서비스 집합 550은 비디오 서비스 또는 오디오 서비스가 아닌 어플리케이션 서비스만으로 구성된 서비스 집합이다. 추상 서비스 집합 550과 상반되고, 비추상 서비스 집합 510은 어플리케이션 서비스만을 구비하고 있지 않은 서비스 집합이다.
도 6 는 스크린 컨텍스트 및 각종 메소드와의 관계를 나타낸다.
도 6 를 참고하면, 스크린 컨텍스트(600)의 일 실시예는, 스크린의 표시 높이 정보(z-order)(610), 디스플레이 영역(620), 가시성(630), 연관된 디스플레이 스크린(640) 및 연관된 서비스 컨텍스트(650)를 포함한다.
표시 높이 정보(이하, 'z-order'라 함.)(610)는 동일한 타입의 구성 요소들이 디스플레이 스크린에서 동시에 표현될 때, 구성 요소들 사이에 앞뒤( 또는 위아래)로 표시되는 순서가 정의된 정보를 의미한다.
디스플레이 영역(620)는 로지컬 스크린의 정규화된 스크린 좌표 공간이 디스플레이 스크린의 정규화된 스크린 좌표 공간에 맵핑되는 영역이다.
가시성(630)은 해당 로지컬 스크린이 디스플레이 스크린 상에서 보이는 상태인지 숨겨진 상태(보이지 않는 상태)인지 여부를 나타낸다.
연관된 디스플레이 스크린(640)는 해당 스크린이 연관된 디스플레이 스크린을 나타내며, 연관 서비스 컨텍스트(650)는 해당 스크린에 연관된 서비스 컨텍스트를 나타낸다.
스크린 컨텍스트(600)는 상기 속성들을 'set/add' 메소드를 통해 설정 또는 추가될 수 있으며, 'get/remove' 메소드를 통해 획득 또는 제거될 수 있다. 즉, 'set/add' 메소드 및 'get/remove' 메소드를 이용하여, 스크린 컨텍스트(600)의 속성의 설정 및 변경이 가능하다.
도 6에 도시되지는 않았지만, 스크린 컨텍스트는 전술된 'z-order', 디스플레이 영역, 가시성, 연관된 디스플레이 스크린, 연관된 서비스 컨텍스트 뿐만 아니라, 현재 스크린과 연관된 오디오 포커스, 현재 스크린과 연관된 오디오 소스, 현 재 스크린과 연관된 스크린 디바이스의 'z-order', 현재 스크린과 연관된 디스플레이 영역, 현재 스크린과 연관된 비디오 출력 포트 중 적어도 하나를 포함할 수 있다.
도 7a 및 7b 는 로지컬 스크린의 z-order에 따른 디스플레이 스크린 상의 결과를 도시한다.
본 발명의 일 실시예에 따른 해당 구성요소의 'z-order'는 값이 클수록 해당 구성요소가 더 위(앞)쪽에 위치하게 된다. 도 7a를 참고하면, 디스플레이 스크린(700) 상에 로지컬 스크린 1a(710) 및 로지컬 스크린 2a(720)가 배치되어 있을 때, 로지컬 스크린 1a(710)의 'z-order'가 1이고, 로지컬 스크린 2a(720)의 'z-order'가 2라면, 로지컬 스크린 2a(720)가 더 위(앞)쪽에 표시된다.
마찬가지로, 도 7b를 참고하면, 디스플레이 스크린(750) 상에 로지컬 스크린 1b(760) 및 로지컬 스크린 2b(770)가 배치되어 있을 때, 로지컬 스크린 1b(760)의 'z-order'가 2이고, 로지컬 스크린 2b(770)의 'z-order'가 1라면, 로지컬 스크린 1b(760)가 더 위(앞)쪽에 표시된다.
'z-order'의 이러한 개념 및 순서는, 로지컬 스크린 뿐만 아니라 스크린 디바이스의 'z-order'에도 동일하게 적용된다.
도 8a 및 8b 는 서비스 컨텍스트, 로지컬 스크린 및 디스플레이 스크린의 연관관계를 도시한다.
비디오 컨텐츠(812), 오디오 컨텐츠(814) 및 어플리케이션 컨텐츠(816)가 포함된 서비스(810)가 수신된 경우를 예로 들어 서비스와 디스플레이 스크린이 직간 접적으로 연관되는 방식이 상술된다.
도 8a를 참조하면, 서비스(810)가 빈 로지컬 스크린(820)에 연관되고, 서비스가 연관된 로지컬 스크린(830)이 디스플레이 스크린(840)에 연관된다면, 디스플레이 스크린 상에 서비스가 표현(850)된다. 즉, 디스플레이 스크린(840)과 서비스(810)이 로지컬 스크린(820, 830)을 통해 간접적으로 연관된다.
도 8b를 참조하면, 서비스(810)가 빈 디스플레이 스크린(840)에 연관된다면, 디스플레이 스크린 상에 서비스가 표현(860)된다. 즉, 디스플레이 스크린(840)과 서비스(810)이 직접적으로 연관된다.
따라서, 본 발명의 일 실시예에서, 디스플레이 스크린에 서비스가 직/간접적으로 연관됨으로써 서비스가 디스플레이 스크린 상에 표시되며, 최종적으로 출력 포트와 연관됨으로써 서비스가 출력될 수 있게 된다.
도 9a 및 9b 는 로지컬 스크린이 맵핑되는 디스플레이 영역에 따른 디스플레이 스크린 상의 결과를 도시한다.
도 9a를 참고하면, 로지컬 스크린(910)이 디스플레이 맵퍼(220)를 통해 디스플레이 스크린(920)의 전체 영역 범위(930)에 맵핑된다면, 로지컬 스크린(910)이 디스플레이 스크린(920)의 전체 범위(930)에 표시(940)된다.
대조적으로, 도 9b를 참고하면, 로지컬 스크린(910)이 디스플레이 맵퍼(220)를 통해 디스플레이 스크린(920)의 일부 영역 범위(950)에 맵핑된다면, 로지컬 스크린(910)이 디스플레이 스크린(920)의 일부 영역 범위(950)에 표시(960)된다.
즉, 본 발명의 일 실시예는, 기존 PiP 방식과 달리 전체 스크린의 일부 영역 에 표현되는 컨텐츠의 스크린도 사이즈를 조절할 수 있다.
도 10 은 복수 개의 서비스, 복수 개의 로지컬 스크린 및 디스플레이 스크린의 연관 관계를 도시한다.
본 발명의 일 실시예에 따른 멀티스크린 매니지먼트 장치는 서비스1(1010)이 연관된 로지컬 스크린1(1030) 및 서비스2(1020)이 연관된 로지컬 스크린2(1040)를 동시에 디스플레이 스크린에 맵핑할 수 있다. 로지컬 스크린들(1030, 1040)이 맵핑된 디스플레이 스크린(1050)가 출력 포트(1060)와 연관되면, 디스플레이부에서 최종 출력 결과(1070)가 재생될 수 있다.
즉, 멀티스크린 매니지먼트 장치는 복수 개의 서비스, 복수 개의 로지컬 스크린, 복수 개의 디스플레이 스크린 및 복수 개의 출력 포트를 구비할 수 있다. 따라서 결과적으로 복수 개의 서비스가 재생되거나, 복수 개의 스크린이 재생되거나, 복수 개의 출력 기관에서 재생되는 효과 등을 얻을 수 있다.
이상 도 2 내지 10을 참고하여 개략적으로 기술된 멀티스크린 설정의 개념뿐만 아니라, 일 실시예에 따른 멀티스크린 매니지먼트 방법 및 멀티스크린 매니지먼트 장치는 멀티스크린 상태의 설정, 변경 및 관리를 위한 제반 동작을 정의한다. 즉, 본 발명의 일 실시예는, 로지컬 스크린 및 디스플레이 스크린 사이의 맵핑 관계, 스크린 디바이스, 서비스 컨텍스트, 디스플레이 스크린과 비디오 출력 포트와의 연관 관계, 오디오 포커스 지정, 디스플레이별 멀티스크린 설정 및 플랫폼별 멀티스크린 설정 등의 획득, 변경, 설정, 판별 / 리소스의 예약 할당 및 예약 할당의 해제 / 각종 변경 등의 동작에 대한 감시 및 통지 / 각종 변경을 위한 전제 조건 및 사후 조건 등을 위한 다양한 기능을 구비하여, 원활한 멀티스크린 설정 및 멀티스크린 매니지먼트가 가능하게 한다. 멀티스크린 설정 및 멀티스크린 매니지먼트를 위한 각종 기능은 이하 실시예들에서 상술된다.
이하, 멀티스크린 매니지먼트 방법 및 장치를 OCAP 시스템에 적용한 실시예가 상술된다.
본 발명은 OCAP 호스트 디바이스를 위한 OCAP 프로파일에 대한 모듈의 확장형을 정의하며, 상기 확장형은 본 명세서에서 정의된 바와 같이 멀티스크린 매니지먼트 기능성을 지원한다. 멀티스크린 매니지먼트 기능성은 호환 가능한 OCAP 어플리케이션이, 멀티스크린을 지원하는 호스트 디바이스의 리소스를 효과적으로 사용하도록 하는 표준화된 소프트웨어 인터페이스로 정의된다.
OCAP MSM 익스텐션은 어플리케이션 레벨에 이르기까지 필요한 모든 어플리케이션 프로그램 인터페이스, 즉 API, 컨텐츠 및 데이터 형식, 프로토콜들의 확장형이다. OCAP MSM 익스텐션으로 개발된 어플리케이션은 Opencable 기반의 호스트 디바이스 상에서 실행될 수 있다. OCAP MSM 익스텐션에서는, 케이블 운영자가, 그들의 네트워크에 관련된 OpenCable 기반의 호스트 디바이스 상에서 멀티스크린 기능성을 관리하기 위해 호환 가능한 어플리케이션을 배치하도록 한다.
본 프로파일에서는, 케이블 운영자가, 복수의 호스트 디바이스 제공 업체들 간에, 멀티스크린 기능성, 및 PiP 스크린 및 PoP 스크린과 같은 멀티스크린 상태를 관리하기 위한 표준화된 인터페이스를 보유할 수 있다.
OCAP MSM 익스텐션은, 가전 제품 제조업체들이 유연하게 구현할 수 있는 매우 다양한 하드웨어 및 운영 시스템에 응용될 수 있다. OCAP MSM 익스텐션을 정의하는 주된 목적은 가전제품 제조업체들이, 멀티스크린 기능성을 인식하기 원하는 케이블 네트워크에 독립적인 어플리케이션 뿐만 아니라 케이블 운영자에 의해 정의된 어플리케이션에 의해 사용되기 위한 일관적이고 호환 가능한 프로그램의 인터페이스를 지원하면서 경쟁적으로 구현하도록 하기 위함이다.
본 발명의 일 실시예에 따른 멀티스크린 매니지먼트 방법 및 장치는 기존 OCAP 표준 규격에 대한 익스텐션(Extension)이다. 본 OCAP MSM 익스텐션은 '시그널링 메커니즘(기술자(desciptors))', '어플리케이션 프로그램 인터페이스(Application Program Interfaces, APIs)', '플랫폼 동작(Platform behavior, 시맨틱(semantics))' 및 '어플리케이션 사용 제한 조건(application usage constraints)'의 형식을 띤다.
일 실시예에서, 본 명세서에 의해 정의된 API는 현존하는 기능성까지의 확장형들의 형식 및 org.havi.ui 패키지에 의해 정의된 바와 같이 HAVi 유저 인터페이스(HAVi User Interface)에 의해 정의된 API(Application Program Interface)를 채택한다. 특히, 여기서 정의된 기능성 중 많은 부분은 'org.havi.ui.HScreen' 클래스를 지원하는 플랫폼에 의해 사용되는 구체적인 클래스에 의해 구현되는 인터페이스의 형식을 채택한다.
이하 기술에서 'HScreen' 인스턴스는 하나의 스크린을 나타낸다. 자바(Java) 타입 또는 파라미터 이름은 도면 상의 영문명을 인용부호('')를 통해 그대로 인용 된다. 자바 클래스는 동일한 유형의 객체를 위한 각종 파라미터, 메소드 등의 집합이며, 자바 인터페이스는 클래스 내의 상호 작용할 객체들의 기능을 명시한다. 자바로 표현된 일 실시예는, 각각의 클래스에 대해 정의된 메소드들을 통해 멀티스크린을 관리 및 설정할 수 있고, 설정 사항을 변경할 수 있다. 인스턴스는 클래스로부터 생성된 객체를 뜻한다.
또한, 이하의 멀티스크린 매니지먼트의 실시예를 설명하는데 있어서 예로 드는 각종 메소드, 각종 필드 및 각종 자바 타입들은 이하 도 11a 내지 도 23d를 통하여 정의된다.
이하, 본 발명의 일 실시예에 따른 OCAP MSM 익스텐션이 Xlet 어플리케이션에서 MSM 관련 작업을 수행할 수 있도록 시그널링하기 위해 선택적으로 채택 가능한 기술자가 정의된다. 이러한 기술자가 없는 경우, 디폴트 시멘틱(default semantics)이 정의된다.
OCAP MSM 익스텐션은 이하 정의된 바와 같이 멀티플 스크린 사용 기술자(multiple screen usage descriptor)를 통해 OCAP 프로파일을 확장한다. AIT 또는 XAIT 상에서 시그널링된 OCAP 어플리케이션은 해당 어플리케이션에 적용되는 어플리케이션 기술자 루프(application descriptor loop) 내에 하나의 멀티플 스크린 사용 기술자를 포함할 수 있다.
멀티플 스크린 사용 기술자가 일부 어플리케이션의 어플리케이션 기술자 루프에 존재하지 않는다면, OCAP 호스트 디바이스는 이러한 멀티플 스크린 사용 기술자가 없는 경우를, 'terminate_on_condition' 플래그가 클리어('0')이고, 'disallow_partial_display_graphics_mapping' 플래그가 클리어('0')이며, 'allow_default_device_reconfig' 플래그가 클리어('0')인 멀티플 스크린 사용 기술자가 존재하는 경우와 동일하게 간주하여야 한다.
이 때, 멀티플 스크린 사용 기술자가 없는 경우를 상정함으로 인해, 디폴트 설정으로써 (ⅰ) 어플리케이션의 디폴트 그래픽 평면(plane)은 (디폴트 배경 및 비디오 평면과 함께,) 중개적인 로지컬 스크린을 통해 디스플레이 스크린의 일부분으로의 크기 변경이 가능하고, (ⅱ) 어플리케이션의 디폴트 스크린 디바이스는 임의적으로 재설정될 수 없거나 리소스가 해제될 수 없으며, (ⅲ) 이러한 지난 조건이 반드시 유지된다면, 어플리케이션은 지연되며, 지연될 수 없다면 종결하게 되는 효과가 있다. 본 명세서 상에서, 어플리케이션이 '지연'된다는 용어는, 어플리케이션이 리소스를 계속 사용하면서 잠시 멈춘 상태를 뜻한다. 또한, 어플리케이션이 '종결'된다는 용어는, 어플리케이션이 리소스를 해제하고 완전히 프로세스를 멈추는 것을 뜻한다.
멀티플 스크린 사용 기술자의 일 실시예는 '기술자 태그'(이하 'descriptor_tag'라 함), '기술자 길이'(이하 'descriptor_length'라 함), '조건적 종료 여부'(이하 'terminate_on_condition'하 함), '부분적 디스플레이에 대한 그래픽 맵핑의 불허 여부'(이하 'disallow_partial_display_graphics_mapping'라 함), '디폴트 디바이스의 재설정 허용 여부'(이하 'allow_default_device_reconfig'라 함), '예약 비트'(이하 'reseved'라 함)를 포함한다.
'descriptor_tag'는 멀티스크린 사용 기술자를 식별하는, 0x6E 값의 8 비트 부호 없는 정수형(unsigned integer)을 나타낸다.
'descriptor_length'는 필드의 바로 뒤에 따라오는 바이트 수를 명시하는 8비트 부호 없는 정수형(unsigned integer)를 나타낸다. 본 명세서에 따르면, 정확히 한 바이트가 'descriptor_length' 필드 뒤에 따라온다.
'terminate_on_condition'은, 'disallow_partial_display_graphics_mapping' 플래그가 참('1')인 경우 또는 'allow_default_device_reconfig' 플래그가 거짓('0')인 경우의 Xlet 어플리케이션의 라이프사이클 상의 지침 사항을 알려주는 1비트 플래그이며, 이 두 가지의 각각의 플래그 중 하나에 의해 명시되는 조건에 의해 어플리케이션이지연 또는 종결되어야 한다.
'terminate_on_condition' 플래그가 참('1')이라면 OCAP 플랫폼은 지배적 조건(governing condition)이 착수될 때 어플리케이션을 종결(무효)시켜야 한다. 반면에, 'terminate_on_condition' 플래그가 거짓('0')이라면 OCAP 플랫폼은 어플리케이션을 지연하도록 시도하여야 하고, 지연할 수 없다면 지배적 조건이 착수될 때 해당 어플리케이션을 종결시켜야 한다.
만약 해당 어플리케이션이 'terminate_on_condition' 플래그가 거짓('0')으로 됨으로써 지연된다면, 지배적 조건이 만족되지 않을 때 해당 어플리케이션은 재개되어야 한다. 그러나 (예를 들어 사용 가능한 리소스가 없을 경우) 해당 어프리케이션이 재개될 수 없다면, 종결(무효)되어야 한다.
현재 컨텍스트에서, '지연'라는 용어는 영향을 받는 어플리케이션의 초기 Xlet 인스턴스의 'pauseXlet()' 메소드를 호출하는 것과 동일한 의미로 해석된다.
'disallow_partial_display_graphics_mapping' 플래그는, 멀티스크린 설정이 변화하거나 서비스 컨텍스트가 교체되거나 스크린 사이에서 이동되어 해당 어플리케이션의 디폴트 그래픽 평면(스크린 디바이스)이, 스크린 영역이 풀 디스플레이 스크린 범위에 맵핑되지 않는 로지컬 스크린에서 작동되도록 크기 조절되려고 할 때, 해당 어플리케이션이 계속 실행될 수 없음을 나타내는 1비트 플래그이다.
만약 'disallow_partial_display_graphics_mapping' 플래그가 참('1')이 된다면, 'terminate_on_condition' 플래그의 값에 따라 'disallow_partial_display_graphics_mapping' 조건이 착수될 때 해당 어플리케이션은 지연되거나 종결되어야 한다. 반면에 'disallow_partial_display_graphics_mapping' 플래그가 거짓('0')이 된다면, 해당 어플리케이션은 상기 조건이 착수될 때 지연되거나 종결되지 않는다.
'allow_default_device_reconfig'는, 멀티스크린 설정이 변화하거나 서비스 컨텍스트가 교체되거나 스크린 사이에서 이동되어 (ⅰ) 일부 디폴트 스크린 디바이스의 하나 이상의 스크린 디바이스 설정(HScreenConfiguration) 파라미터, 예를 들어 스크린 영역, 픽셀 해상도 또는 픽셀 가로세로비율 정보가 변하거나, (ⅱ) 설정 변화 또는 서비스 컨텍스트 교체/이동 전에 존재한 하나 이상의 디폴트 스크린 디바이스의 기저 리소스가, 설정 변화 또는 서비스 컨텍스트 교체/이동 후 더 이상 이용 가능하지 않게 될 때, 해당 어플리케이션이 계속 실행될 수 있음을 나타내는 1비트 플래그이다.
만약 'allow_default_device_reconfig' 플래그가 거짓('0')이 된다면, 'terminate_on_condition' 플래그의 값에 따라 'allow_default_device_reconfig' 조건이 착수될 때 해당 어플리케이션은 지연되거나 종결되어야 한다. 반면에 'allow_default_device_reconfig' 플래그가 참('1')이 된다면, 해당 어플리케이션은 상기 조건이 착수될 때 지연되거나 종결되지 않는다.
이 경우, 참('1') 상태인 'allow_default_device_reconfig' 플래그를 시그널링하는 어플리케이션은 'org.havi.ui.HScreenConfigurationEvent' 자바 타입 및 'org.ocap.ui.MultiScreenEvent' 자바 타입을 위한 리스너(listener)를 등록하고 처리해야 한다.
'reserved' 필드는 향후의 표준화를 위해 예약 할당된 필드이며, 모두 '1'의 값을 설정된다.
이하, OCAP MSM 익스텐션을 위한 어플리케이션 프로그램 인터페이스에 대해 상술된다.
본 발명의 일 실시예는 Java 타입에 의해 상술된다. 다만, 본 발명의 실시예가 Java 타입의 실시예로만 한정되는 것이 아니며, 본 발명의 목적 및 효과를 구현하기 위한 방식은 해당 기술 분야에서 일반적인 자들에게 자연스럽게 구현할 수 있는 다양한 방식을 포함함을 유의해야 한다.
OCAP MSM 익스텐션은 복수 개의 스크린에 관한 특성을 지원하는 플랫폼 구현에 있어서 복수 개의 디스플레이 스크린 및 복수 개의 로지컬 스크린을 효과적으로 사용하기 위한 기능성 및 동작의 집합이다. MSM 익스텐션은 이하 기술되는 멀티플 스크린 매니지먼트 기능성을 부가함으로써 OCAP 프로파일을 확장한다.
OCAP MSM 익스텐션을 지원하는 OCAP 호스트 디바이스는 후술되는 시맨틱을 지원해야 한다.
이하, 멀티스크린 매니저(Multiscreen Manager, MSM)에 대해 상술된다.
OCAP 어플리케이션을 위한 디폴트 'HScreen'은 현재 활성화된 디폴트 기저 스크린 디바이스들 및 그 스크린 디바이스들의 현재 활성화된 HAVi 스크린 설정을 표현하는 'HScreen' 인스턴스이다.
어플리케이션의 디폴트 'HScreen'에 대한 그 이상의 정보는 후술될 디폴트 HScreen 지정 방식 및 'MultiScreenManager.getDefaultHScreen()' 메소드에서 상술된다.
멀티스크린 매니저 클래스(MultiscreenManager class)를 구현하는 OCAP 호스트 디바이스는, OCAP 구현의 영향을 받는 각각의 부 시청 스크린 및 주 시청 스크린, 즉 PiP 스크린 및 넌-PiP 스크린 모두를 위한 별개의 로지컬 'HScreen' 인스턴스를 제공하여야 한다.
이하, 스크린(Screens)에 대해 상술된다.
기본적인 HAVi 모델로 지칭되기도 하는 HAVi 유저 인터페이스 서브시스템은, 스크린을 'HScreen' 클래스로 정의한다. 'HScreen' 클래스는 "디바이스의 최종 출력 설정부"이라는 기술이 되도록 정의되며, "두 가지 독립 디스플레이를 구비하는 플랫폼은 'HScreen' 클래스의 두 인스턴스를 지원할 수 있음"으로 표현되어 있다. MSM 익스텐션의 도입과 함께, 이러한 'HScreen' 클래스의 정의는 디스플레이 스크 린 및 로지컬 스크린 사이의 구별되는 개념을 도입하기 위해 확장된다.
먼저, '디스플레이 스크린'으로부터 'HScreen' 클래스의 확장된 개념이 상술된다.
"물리적 디스플레이 장치의 최종 출력 설정부"를 구성하는 스크린은 MSM에서 '디스플레이 스크린'이라 지칭된다. 대조적으로, 하드웨어 또는 소프트웨어 중 하나를 통한 논리적 좌표계 시스템 변환 과정을 통해 디스플레이 스크린에 맵핑되는 스크린은 '로지컬 스크린'이라 지칭된다.
비디오 출력 포트 연관 관계에 있어서, 디스플레이 스크린은 비디오 출력 포트에 전혀 연관 또는 맵핑되지 않거나, 하나 이상의 비디오 출력 포트에 연관될 수 있고, 이런 비디오 출력 포트는 'VideoOutputPort'에 의해 정의된 대로 독립적으로 활성화될 수 있고 비활성화될 수도 있다. 만약 디스플레이 스크린이 어떤 비디오 출력 포트와도 연관되지 않는다면, 재생 디바이스는 디스플레이 스크린의 컨텍스트에서 활성화된 재생 작업이라도 실제 재생 디바이스에서 출력되지 않는다..
MSM의 컨텍스트 상에서 디스플레이 스크린의 연관 관계에 있어서, 오디오 출력 의 출력을 위한 오디오 출력과 디스플레이 스크린 간의 '오디오 출력 포트 연관 관계'는 디스플레이 스크린과 비디오 출력 포트와의 연관 관계에 의해서 결정된다.
디스플레이 스크린은, 디스플레이 스크린 자체 또는 디스플레이 스크린에 맵핑된 로지컬 스크린 중 하나를 디스플레이 스크린의 '오디오 포커스 스크린'이 되도록 지명한다. '오디오 포커스 스크린'은, 어느 오디오 소스가 디스플레이 스크린이 맵핑된 비디오 출력 포트들과 연관된 오디오 출력들에서 실행되는지를 결정하기 위해 사용된다. 일 실시예에서 오디오 출력들은 내재된 오디오 출력일 수도 있다. 이러한 구별은, PiP 또는 PoP 멀티스크린 설정의 경우과 같이, 디스플레이 스크린에 동시에 맵핑되고 재생되고 있는 복수 개의 로지컬 스크린들이 있는 경우에만 필요하다.
로지컬 스크린이 디스플레이 스크린에 맵핑되지 않거나 또는 로지컬 스크린에 오디오 포커스가 연관되지 않은 경우, 오디오 포커스는 디스플레이 스크린 자체에 지정된다. 이 경우, 디스플레이 스크린에 연관된 'HScreenDevice' 인스턴스, 즉 스크린 디바이스는 오디오 소스로써 잠재적인 후보가 된다.
'디스플레이 스크린'에 이어, '로지컬 스크린'은 "디바이스의 최종 출력 설정부"라는 구문 중 "디바이스"가, '물리적 디바이스'와 상반되는 개념으로써 "로지컬 디바이스"로 표현되도록 'HScreen'의 기본적인 HAVi 모델이 자연스럽게 확장된 개념이다. 로지컬 디바이스의 이해를 위해, 물리적 디스크 드라이버의 일부분이 마치 본래 독립적인 디스크 드라이브인 것처럼 보일 수 있게 한다는 로지컬 디스크 드라이브의 개념을 참고하면, 로지컬 디바이스는 로지컬 디스크 드라이브의 널리 이해되는 개념과 크게 다르지 않다.
OCAP 어플리케이션의 관점에 의하면 로지컬 스크린의 의도 및 목적도 디스플레이 스크린과 같다. 로지컬 스크린은 멀티스크린을 지원하지 않는 기존 'HScreen' 인스턴스의 모든 표준 속성 및 동작들을 포함한다. 멀티스크린을 지원하지 않는 기존 'Hscreen' 인스턴스의 모든 표준 속성 및 동작들은, 디폴트 스크린의 배경 스크린 디바이스들, 비디오 스크린 디바이스들 및 그래픽 스크린 디바이스들, 상기와 동일한 타입의 추가적인 넌-디폴트 스크린 디바이스들, 하나 이상의 일관적인 스크린 디바이스 설정들, 상기 디바이스들의 일관적인 스크린 설정들을 설정하기 위해 스크린 디바이스들을 세부적으로 변경하는 능력, 및 스크린 디바이스 설정 템플릿의 경우 소정 타입의 스크린 디바이스의 최적 설정을 결정하기 위한 메커니즘를 포함한다.
각각의 로지컬 스크린은, 기본적인 HAVi 모델에 의해 정의된 독립적이고 정규화된 스크린 좌표 공간을 구비한다. 로지컬 스크린은 일반적으로 디스플레이 스크린 및 상기 디스플레이 스크린 상의 디스플레이 영역에 연관된다. 이 연관 관계를 통해, 로지컬 스크린의 정규화된 스크린 좌표 공간은 디스플레이 스크린의 정규화된 스크린 좌표 공간의 스크린 구형(사각형의 스크린)에 맵핑된다. 이하 설명의 편의 상 스크린 구형으로 디스플레이 영역이 표현되지만, 본 발명이 적용가능한 스크린이 구형, 즉 사각형 모양에 한정되는 것은 아니다.
스크린 구형(이하 '디스플레이 영역'이라 함.)은 전체 디스플레이 스크린 범위와 일치할 수 있으며, 이 경우 맵핑 과정은 두 가지 정규화된 스크린 좌표 공간 사이의 동일성 맵핑 과정이다.
또한 스크린 구형이 디스플레이 스크린의 일 부분에 일치될 수도 있으며, 이 경우 디스플레이 영역은 디스플레이 스크린의 가시 부분에 전부 포함될 수 있고, 또는 디스플레이 스크린의 가시 부분의 바깥에 전부 포함될 수 있으며, 또는 디스플레이 스크린의 가시 부분 및 비가시 부분 (또는 가시 부분의 외부)의 양 쪽에 교차될 수도 있다.
디스플레이 영역의 일 부분이 디스플레이 스크린의 가시 디스플레이 부분의 바깥(즉, 디스플레이 스크린의 [0,0], [1,1]의 스크린 구형 바깥)으로 확장된다면, 해당 영역이 디스플레이 스크린의 (명목상) 가시 부분으로 외부적으로 잘라지는지 아닌지 여부는 구현 상의 선택 사항이다.
각각의 로지컬 스크린은 디폴트 스크린 디바이스들을 구비하며, 각각의 디폴트 스크린 디바이스는 'HScreenDevice' 인스턴스의 세부적인 서브타입인 'HBackgroundDevice'(백그라운드 디바이스), 'HVideoDevice'(비디오 디바이스), 'HGraphicsDevice'(그래픽 디바이스)로 표현된다. 또한, 기본적인 HAVi 모델과 같이, 각각의 로지컬 스크린은 각각의 상기 서브 타입의 부가적인 넌-디폴트 스크린 디바이스들을 구비할 수 있다.
기본적인 HAVi 모델과 같이, 로지컬 스크린에 의해 사용되는 각각의 기저 스크린 디바이스 리소스는 'HScreenDevice' 클래스의 표준 서브타입을 통해 참조된다. 각각의 스크린 디바이스는, 기본적인 HAVi 모델에 의해 정의되고 'HScreenConfiguration' 클래스의 표준 서브 타입에 의해 표현되는 설정 파라미터들을 구비한다.
예를 들면, 상기 설정 파라미터는, 템플릿이 선호(template preference)하는 'HScreenConfigTemplate.PIXEL_RESOLUTION'에 의해 설계되고, 도우미 함수(helper function) 'HScreenDevice.getPixelResolution()'을 사용하여 억세스 가능하다. 기본적인 HAVi 모델의 넌-멀티스크린 구현 상의 'HScreenDevice' 인스턴스의 경우와 같이, 로지컬 스크린의 스크린 디바이스를 참조할 때 'HScreenConfigTemplate.PIXEL_RESOLUTION' 역시 존재하며 동일한 메소드들을 통해 억세스 가능하다.
그러나 여기서 정의된 로지컬 스크린의 경우, 픽셀 해상도는 로지컬 스크린이 맵핑되는 디스플레이가 아닌, 로지컬 스크린의 정규화된 좌표 공간의 컨텍스트 상의 스크린 디바이스의 해상도이다. 궁극적으로, 로지컬 스크린의 스크린 디바이스의 픽셀 해상도는, 2차 좌표 공간 변환을 통해, 디스플레이 스크린의 정규화된 스크린 좌표 공간에 맵핑된다. 그러나, 논리적 처리의 관점에 의해 로지컬 스크린은 실제 물리적 디스플레이 디바이스로의 최종 출력 신호와 다르지 않으므로, 로지컬 스크린을 사용하는 어플리케이션은 이러한 2차 변환식을 알 필요는 없다.
로지컬 스크린의 정규화된 좌표 공간 및 디스플레이 스크린의 정규화된 좌표 공간(전술된 2차 좌표 공간 변환)의 로지컬 스크린과 연관된 디스플레이 영역 사이의 맵핑 과정(이하 '디스플레이 맵핑 과정'이라 함)은 '논리적 맵핑 과정'으로 정의되며, MSM 구현 방식에 의하면 상기 맵핑 프로세스에 세부적인 하드웨어 컴포넌트가 부가될 필요 없다.
예를 들면, 한 구현의 선택은, 소정 디스플레이 스크린에 맵핑하는 모든 로지컬 스크린의 (리소스가 지정된) 모든 스크린 디바이스들을, 단일 디스플레이 스크린 상의 단일 스크린 디바이스로 (내부적으로) 모델링하는 것이다. 이때, 상기 모델링에는 스크린 디바이스들 사이의 픽셀 일관성(pixel coherency) 및 'z-order'에 대한 소정 제한 조건이 적용된다.
특히, 일부 픽셀 일관성 규칙들이 일부 로지컬 스크린의 주어진 (하위) 스크 린 디바이스들에 적용된다면, 상기 로지컬 스크린의 스크린 디바이스들이 디스플레이 스크린 상의 (명목상 맵핑된) 더 많은 스크린 디바이스들의 일 부분으로 간주될 때, 상기 픽셀 일관성 규칙들도 적용된다.
유사하게, 디스플레이 스크린의 (명목상 맵핑된) 스크린 디바이스들의 'z-order' 는 (ⅰ) 각각의 로지컬 스크린 내의 스크린 디바이스의 z-order 및 (ⅱ) 로지컬 스크린 사이의 'z-order'을 반영하여야 한다. 다르게 표현하면, 다른 로지컬 스크린의 (명목상 맵핑된) 스크린 디바이스들은 상호 교차되지(interleaved) 않는다.
(로지컬 스크린으로부터 디스플레이 스크린으로의) 디스플레이 맵핑 프로세스가 논리적 수단 또는 물리적(하드웨어) 수단 중 어느 수단에 의해 수행되는지 간에, 상기 맵핑 프로세스에 영향을 미치는 것은 주어진 로지컬 스크린 및 디스플레이 스크린 쌍을 위한 '디스플레이 맵퍼(display mapper)'로 지칭된다.
이하, 로지컬 스크린의 '비디오 출력 포트 연관 관계'가 상술된다.
일반적인 환경에서, 로지컬 스크린은 비디오 출력 포트에 직접적으로 연관된 디스플레이 스크린에 연관되므로, 비디오 출력 포트에 간접적으로 연관된다. 그러나, 유연성을 더하기 위해 MSM은 로지컬 스크린이 비디오 출력 포트에 직접적으로 연관될 수 있게 한다.
로지컬 스크린은, (ⅰ) 로지컬 스크린이 고립된 경우, 즉 디스플레이 스크린에 맵핑되지 않고, 비디오 출력 포트에 직접적으로 연관되어, 디스플레이 스크린처럼 독립적으로 작동하는 경우, 및 (ⅱ) 로지컬 스크린이 디스플레이 스크린에 연관 되어 디스플레이 스크린과 연관된 비디오 출력 포트에 간접적으로 연관된 동시에, 디스플레이 스크린인 것처럼 독립적으로 작동하면서 부가적으로 다른 비디오 출력 포트에 직접적으로 연관된 경우의 두 가지 환경에서 비디오 출력에 직접적으로 연관된다. 전술된 두 가지 경우를 포함하는 사용례가 각각 후술된다.
1. 고립된 로지컬 스크린이, (예를 들어 디지털 비디오 레코드(Digital Video Recorder, DVR) 기능성에 의해,) 그 컨텐츠가 기록된 서비스 컨텍스트에 부가되고, 이와 동시에 1394 또는 NTSC 컴포짓 포트(composite port)와 같은 보조 비디오 출력 포트에 상기 컨텐츠를 출력하길 요청되는 경우.
2. 로지컬 스크린이, 메인 스크린도 동시에 재생되고 있는 PiP 멀티스크린 설정 상의 디스플레이 스크린에 맵핑되는 PiP 스크린으로써 재생되고, 상기 디스플레이 스크린이 주 비디오 출력 포트에 연관되어 있으며, 추가적으로 이러한 PiP 로지컬 스크린이 1394 또는 NTSC 혼성 포트와 같은 보조 비디오 출력 포트에 직접적으로 출력되길 요청되는 경우.
로지컬 스크린의 비디오 출력 포트 연관 관계와 유사하게, '오디오 출력 포트 연관 관계'에 있어서도, 로지컬 스크린은, (ⅰ) 디스플레이 스크린에 맵핑됨으로써 비디오 출력 포트에 간접적으로 연관되거나, 또는 (ⅱ) 전술된 바와 같이 비디오 출력 포트에 직접적으로 연관됨으로써, 오디오 출력 포트에 간접적으로 연관된다.
복수 개의 로지컬 스크린이 디스플레이 스크린에 맵핑될 때, 일반적으로 단 하나의 로지컬 스크린만이 소정 시간에 실행되기 위한 오디오 소스와 관련된다. 상 기 하나의 로지컬 스크린이 디스플레이 스크린의 오디오 포커스 스크린으로 지명되고, 'MultiScreenConfigurableContext.assignAudioFocus()' 메소드를 이용하여 결정된다.
단일 로지컬 스크린은 넌-디폴트 인스턴스 뿐만 아니라 디폴트 'HScreenDevice' 인스턴스로부터 유도됨으로써 오디오의 복수 개의 소스를 구비할 수 있으므로, 상기 인스턴스들 중 어느 인스턴스가 로지컬 스크린과 연관된 오디오 출력에 관여할지 여부를 제어하는 것이 바람직하다. 이러한 오디오 소스는 'MultiScreenConfigurableContext.add,removeAudioSources(..)' 메소드를 이용하여 결정된다.
이하, 스크린 타입이 정의된 스크린 카테고리('Screen Category')가 상술된다.
앞서 정의된 디스플레이 스크린 및 로지컬 스크린 뿐만 아니라, 멀티스크린 설정 상의 각각의 스크린은 이하의 미리 정의된 'Screen Category', 즉 스크린 카테고리 중 하나 또는 'x-'로 시작되는 스트링 표현을 갖는 플랫폼에 의존적인 카테고리로 지정된다.
즉, 'None(SCREEN_CATEGORY_NONE)', 'Display(SCREEN_CATEGORY_DISPLAY)', 'Main(SCREEN_CATEGORY_MAIN)', 'PiP(SCREEN_CATEGORY_PIP)', 'PoP(SCREEN_CATEGORY_POP)', 'Overlay(SCREEN_CATEGORY_OVERLAY)', 'General(SCREEN_CATEGORY_GENERAL)'의 스크린 카테고리가 존재한다.
이러한 스크린 카테고리는 'MultiScreenConfiguration' 인터페이스의 상기 소정 필드에 의해, 확장 가능한 스트링 목록으로 명백하게 정의된다. 더 이상의 세부적인 카테고리가 적용되지 않는 경우에만, 스크린이 'SCREEN_CATEGORY_NONE'의 카테고리로 분류된다.
이하, 스크린 식별자('Screen Identifier')가 상술된다.
디스플레이 스크린 또는 로지컬 스크린을 종합적으로 표현하는 각각의 식별가능한 스크린 리소스들은 '스크린 식별자'(screen identifier)라는 고유 (스트링) 식별자로 지정되며, 여기서 고유성의 의미의 범위는 주어진 시간에 모든 활성화된 멀티스크린 설정을 통해 억세스 가능한 모든 스크린들을 포함한다. MSM 구현은 고유성의 범위를 소정 시간에 모든 비활성화된 멀티스크린 설정을 포함하도록 확장시킬 수 있으며, 고유성의 범위를 (콜드 부트 사이클 사이에) 플랫폼이 작동하는 모든 연속적인 기간을 포함하도록 확장할 수 있다.
로지컬 스크린이나 디스플레이 스크린의 동적인 런타임(run-time)의 추가를 지원하는 MSM 구현은, 추가시 고유성의 최소한의 범위에 대한 상기 제한 조건을 유지하는 식별자를 지정할 수 있도록 준비되어야 한다.
멀티스크린 설정은 '플랫폼별 디스플레이 멀티스크린 설정' 및 '디스플레이별 멀티스크린 설정'을 포함한다.
소정 시간에, 디스플레이 스크린들의 (대체적으로 특정, 필수적으로 적합하여야 한 것은 아닌) 특정한 서브셋은, 디스플레이 스크린들이 가시 상태(visible)로 표시되어 있으면 동시에 컨텐츠를 실행하거나 하나 이상의 로지컬 스크린으로부터의 컨텐츠가 재생될 수 있다는 의미에서, MSM 구현의 컨텍스트 상에서 활성 상태 이다. 디스플레이 스크린들의 이러한 서브셋은 '플랫폼별 디스플레이 멀티스크린 설정(per-platform display multiscreen configuration)'으로 지칭되고, 'MultiScreenConfiguration' 인터페이스를 구현하는 객체를 이용하여 MSM에 의해 모델링된다. 여기서 'MultiScreenConfiguration' 인터페이스의 'getConfigurationType()' 메소드는 'MultiScreenConfiguration.SCREEN_CONFIGURATION_DISPLAY' 값을 반환한다.
현재 활성화된 플랫폼별 멀티스크린 설정은 'MultiScreenManager.getMultiScreenConfiguration()'에 의해 획득되고, 'MultiScreenManager.setMultiScreenConfiguration()'에 의해 설정된다.
게다가, 플랫폼 멀티스크린 설정에 참여하는 각각의 디스플레이 스크린에 대해, 상기 디스플레이 스크린의 컨텍스트 상에서 활성화된 (현존하는) 로지컬 스크린들의 (대체적으로 적합한) 특정 서브셋이 존재하여, 일부 상기 로지컬 스크린이 가시 상태(visible)로 표시되어 있으면, 하나 이상의 서비스 컨텍스트들 또는 미디어 플레이어들에서 동시에 컨텐츠가 재생 중이거나 재생될 수 있다. 로지컬 스크린의 이러한 서브셋은 '디스플레이별 멀티스크린 설정(per-display multiscreen configuration)'으로 지칭되며, 'MultiScreenConfiguration' 인터페이스를 구현하는 객체를 사용하는 MSM에 의해 모델링될 수 있다. 여기서, 'MultiScreenConfiguration' 인터페이스의 'getConfigurationType()' 메소드는 'MultiScreenConfiguration.SCREEN_CONFIGURATION_DISPLAY'이 아닌 값을 반환한다.
소정 디스플레이 스크린의 현재 활성화된 디스플레이별 멀티스크린 설정은 'MultiScreenContext.getMultiScreenConfiguration()' 메소드에 의해 획득되고, 'MultiScreenConfigurableContext.setMultiScreenConfiguration()' 메소드에 의해 설정된다. (소정 디스플레이 스크린에 대해 사용될 수 있는) 모든 억세스 가능한 유용한 디스플레이별 멀티스크린 설정들은 'MultiScreenContext.getMultiScreenConfigurations()' 메소드에 의해 획득될 수 있다.
현재 사용 중인지 여부와 상관 없이, 그리고 플랫폼별 또는 디스플레이별 멀티스크린 설정인 여부와 상관 없이 모든 억세스 가능한 멀티스크린 설정들은 'MultiScreenManager.getMultiScreenConfigurations()' 메소드에 의해 획득될 수 있다.
현재 활성화된 멀티스크린 설정의 단 하나의 HScreen 인스턴스만이 종료되지 않은(non-terminated) 각각의 OCAP 어플리케이션의 디폴트 스크린의 기저 리소스와 동일하여야한다. 이때, 상기 현재 활성화된 멀티스크린 설정은 현재 활성화된 플랫폼별 멀티스크린 설정 상의 디스플레이 스크린에 대한 일부 현재 활성화된 멀티스크린 설정이다.
멀티스크린 설정으로 모델링되는 각각의 스크린들은 후술되는 소정 설정 타입 중 하나 또는 'x-'로 시작되는 스트링 표현을 갖는 플랫폼에 의존적인 설정 타입인 '멀티스크린 설정 타입'으로 지정된다.
'멀티스크린 설정 타입'은 'Display(SCREEN_CONFIGURATION_DISPLAY)', 'Non-PiP(SCREEN_CONFIGURATION_NON_PIP)', 'PiP(SCREEN_CONFIGURATION_PIP)', 'PoP(SCREEN_CONFIGURATION_POP)', 'General(SCREEN_CONFIGURATION_GENERAL)'를 포함한다.
이러한 설정 타입은 'MultiScreenConfiguration' 인터페이스의 전술된 필드에 의해 확장 가능한 스트링 목록으로 형식적으로 정의된다.
멀티스크린 설정은 억세스 가능한 스크린 중 하나를 '디폴트 서비스 컨텍스트 연관 스크린(default service context association screen)'으로 지명한다. 디폴트 서비스 컨텍스트 연관 스크린은 더 세부적인 연관 정보가 없는 경우 서비스 컨텍스트 및 스크린 사이의 디폴트 연관 관계(default association). 기본적인 연관 관계를 결정하기 위하여 사용된다.
각각의 미리 정의된 멀티스크린 설정 타입은 소정 스크린을 '초기' 디폴트 서비스 컨텍스트 연관 스크린으로 정의한다. 플랫폼 부팅 시간 이후에는, 'MultiScreenConfiguration.setDefaultServiceContextScreen(..)' 메소드를 이용함으로써 멀티스크린 설정의 디폴트 서비스 컨텍스트 연관 스크린이 변경될 수 있다. 멀티스크린 설정의 현재 디폴트 서비스 컨텍스트 연관 스크린은 'MultiScreenConfiguration.getDefaultServiceContextScreen()' 메소드를 사용함으로써 획득될 수 있다.
더 이상의 정보를 위해, 후술되는 'MultiScreenManager.setMultiScreenConfiguration(..)' 메소드, 'MultiScreenConfigurableContext.setMultiScreenConfiguration(..)' 메소드, 특히, 상기 메소드들의 'serviceContextAssociations' 파라미터의 설명이 후술된다.
'디폴트 멀티스크린 설정'은 '디폴트 플랫폼별 멀티스크린 설정' 및 '디폴트 디스플레이별 멀티스크린 설정'을 포함한다.
MSM 익스텐션을 구현하는 OCAP 호스트 디바이스의 콜드 부팅(또는 재시작)이 수행된 후, 디폴트 (초기에 활성화된) 플랫폼별 멀티스크린 설정은 콜드 재시작 이전에 활성 상태 상태였던 멀티스크린 설정과 동일하여야 한다. 만약 이전의 플랫폼별 멀티스크린 설정을 알 수 없다면, 디폴트(초기 활성 상태) 플랫폼별 멀티스크린 설정은 'MultiScreenManager.getMultiScreenConfigurations(SCREEN_CONFIGURATION_DISPLAY)' 메소드에 의해 반환되고 디스플레이 스크린에 연관되는 첫 번째 멀티스크린 설정이어야 하며, 이때 차례대로 상기 디스플레이 스크린은 'SCREEN_CONFIGURATION_NON_PIP' 설정 타입의 디스플레이별 멀티스크린 설정과 연관되어야 한다.
유사하게, 디폴트 플랫폼별 멀티스크린 설정의 각각의 디스플레이 스크린의 디폴트 (초기에 활성화된) 디스플레이별 멀티스크린 설정은 콜드 재시작 이전에 활성 상태였던 멀티스크린 설정과 동일하여야 한다. 만약 일부 디스플레이 스크린에 대한 이전 디스플레이별 멀티스크린 설정을 알 수 없다면, 해당 디스플레이 스크린 상의 'MultiScreenContext.getMultiScreenConfigurations(SCREEN_CONFIGURATION_NON_PIP)' 메소드에 의해 반환되는 설정 타입 'SCREEN_CONFIGURATION_NON_PIP'의 첫 번째 멀티스크린 설정이어야 한다.
MSM 익스텐션을 구현하는 OCAP 호스트 디바이스 또는 OCAP 환경의 (넌-콜드) 재시작, 리부팅 및 리셋 중 어느 하나가 수행될 때, 디폴트 (초기에 활성화된) 멀티스크린 설정은 넌-콜드 재시작, 리부팅 또는 환경 리셋 이전에 활성 상태였었던 멀티스크린 설정과 동일하여야 한다.
이하, 스크린 디바이스(screen device)의 정의가 상술된다.
하나의 'HScreen' 인스턴스는 디바이스로부터의 단일 독립 비디오 출력 신호를 표현한다. 복수 개의 독립 비디오 출력 신호를 구비하는 디바이스는 'HScreenDevice' 클래스의 복수 개의 인스턴스를 지원하여야 한다. 비디오 출력 신호는, 'HScreenDevice' 클래스로부터 상속하는 많은 객체들로 표현되는 디바이스들이 함께 추가적으로 관여함으로써 생성된다. 상기 객체들은 'HGraphicsDevice' 객체, 'HVideoDevice' 객체, 및 'HBackgroundDevice' 객체일 수 있다. 해당 API에 관한 한, 주어진 'HScreen'는 상기 객체들 중 복수의 객체들을 지원할 수 있다. 다만, 일부 형식의 프로파일링(profiling)이 상기 객체들의 개수를 제한할 수 있다. 제한적인 환경에서의 일 실시예에서는, 'HGraphicsDevices' 인스턴스, 'HVideoDevice' 인스턴스, 및 'HBackgroundDevice' 인스턴스의 각각 하나씩 함께 재생되도록 할 수 있다.
'HBachgroundDevice' 클래스, 즉 백그라운드 디바이스는 스크린의 근본적인 백그라운드, 즉 배경 색상 및 배경 이미지를 나타낸다. 백그라운드는 비디오/그래픽 컴포지션 스택(video/graphics composition stack)의 바로 뒤에 위치한다. 백그 라운드는 스크린의 전체 영역을 잠재적으로 덮을 수 있다. 디바이스가 스크린 상의 복수 개의 어플리케이션들을 동시에 지원하거나 윈도우 매니저(window manager)라도 지원하면, 백그라운드는 특정 어플리케이션 또는 윈도우에 한정되지 않는다. 리소스가 부족하면 스크린의 백그라운드가 제어되며, 부족한 리소스에 따라 백그라운드 제어가 관리된다.
'HGraphicsDevice' 클래스, 즉 그래픽 디바이스는 소정 'HScreen'에게 적용 가능한 래스터 그래픽 디바이스를 기술한다. 각각의 'HGraphicsDevice'는, 'HGraphicsDevice'와 연관된 하나 이상의 'HGraphicsConfiguration' 객체들을 구비한다. 'HGraphicsConfiguration' 객체들은 'HGraphicsDevice'가 사용될 수 있는 별개의 설정들(configurations)을 자세히 설명한다.
'HVideoDevice' 클래스, 비디오 디바이스는 소정 스크린의 재생 상태(appearance)에 관여할 수 있는 로지컬 비디오 디바이스를 기술한다. 각각의 'HVideoDevice'는, 해당 'HVideoDevice'과 연관된 하나 이상의 'HVideoConfiguration' 객체들을 구비한다. 'HVideoConfiguration' 객체들은 'HVideoDevice'이 사용될 수 있는 별개의 설정들을 자세히 설명한다. 'HVideoDevice' 클래스는 비디오만을 표현하며, 어느 비디오가 재생될지를 선택하지는 않는다.
상기 'HScreenDevice' 클래스 뿐만 아니라, 'HBackgroundDevice' 클래스, 'HGraphicsDevice' 클래스, 및 'HVideoDevice' 클래스는 HAVi 유저 인터페이스(HAVi User Interface)를 위한 'org.havi.ui' 패키지에서 정의된다.
'HBackgroundDevice' 클래스는 'public class HBackgroundDevice'로 선언되며, 'extends HScreenDevice'로 확장한다. 'HBackgroundDevice' 클래스는 'HScreenDevice' 클래스로부터 상속되는 객체들에 의해 표현되는 백그라운드 디바이스를 기술한다.
'HGraphicsDevice' 클래스는 'public class HGraphicsDevice'로 선언되며, 'extends HScreenDevice'로 확장한다. 'HGraphicsDevice' 클래스는 'HScreenDevice' 클래스로부터 상속되는 객체들에 의해 표현되는 그래픽 디바이스를 기술한다.
'HVideoDevice' 클래스는 'public class HVideoDevice'로 선언되며, 'extends HScreenDevice'로 확장한다. 'HVideoDevice' 클래스는 'HScreenDevice' 클래스로부터 상속되는 객체들에 의해 표현되는 비디오 디바이스를 기술한다.
이하, 멀티스크린 설정의 변경 동작이 상술된다.
('MonitorAppPermission("multiscreen.configuration")'가 허용된) 권한을 가진 어플리케이션(privileged application)은, 일부 디스플레이 스크린의 'MultiScreenManager' 인스턴스 및 'MultiScreenConfigurableContext' 인터페이스 중 어느 하나의 'setMultiScreenConfiguration(..)' 메소드 또는 'requestMultiScreenConfigurationChange(..)' 메소드를 통해 현재 멀티스크린 설정을 변경할 수 있다. 또한, 본 명세서에서 정의되지 않은 다른 이벤트들의 결과로써 호스트 디바이스 자체에 의해 변경될 수 있다. 예를 들면, 제작자가 세부적인 멀티스크린 설정을 활성화시키는 외부 원격 조정 키를 제공할 수도 있다.
어떤 원인에 의해 현재 멀티스크린 설정이 변경되는지에 관계 없이, 멀티스크린 설정이 변경되려면 후술되는 제한 조건이 만족되어야 한다.
1.변경 이전에는, 후술되는 전제 조건이 만족되어야 한다.
2.변경 도중에는, 후술되는 변경 처리 단계가 만족되어야 하며, 후술되는 동적 상태 불변성이 만족된다.
3.변경 이후에는, 후술되는 사후 조건이 만족되어야 한다.
폭넓은 호환 가능성을 위해, 많은 전제 조건 및 사후 조건이, 각각 도 24a 내지 24c 및 도 25a 내지 25e의 'Assertions' 형식의 의사 코드(pseudo code)로 표현되어 있다. 도 24a 내지 24c 및 도 25a 내지 25e에 기재된 제한 조건은 후술되는 제한 조건에 있는 설명과 동일한 의도이다. 후술되는 제한 조건이 도 24a 내지 24c 및 도 25a 내지 25e의 코드과 다르거나 코드 문에 일부만 나타난 경우 후술되는 제한 조건이 도 24a 내지 24c 및 도 25a 내지 25e의 코드보다 우선권이 있다. 후술되는 제한 조건의 우선권에도 불구하고, 도 24a 내지 24c 및 도 25a 내지 25e는 MSM 익스텐션의 호환 가능한 구현에 부합하도록 하는 목적에 적용되어야 한다.
먼저, 멀티스크린 설정 변경을 위한 전제 조건이 상술된다.
멀티스크린 설정 변경의 결과로 발생되는 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 이전에, 후술되는 전제 조건이 순서대로 준수되어야 한다.
1. 후술되는 '정지 상태 불변성'이 만족되어야 한다.
둘째, 멀티스크린 설정을 변경하기 위한 과정이 상술된다.
MSM 구현은 현재 멀티스크린 설정을 변경하기 위해 후술되는 순서의 단계를 수행하여야 한다.
1. 어플리케이션의 결과를 전송(dispatch)하기 위한 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트를 생성한다.
2.'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트가 생성되어 변경을 시작하고, 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED'가 생성될 때까지, OCAP 어플리케이션은 (ⅰ) 현재 멀티스크린 설정의 변경, (ⅱ) 'HScreen' 또는 'HScreenDevice', 및 'HScreen' 또는 'HScreenDevice' 의 기저 리소스의 예약 할당, (ⅲ) 스크린 디바이스 설정의 변경 또는 멀티스크린 스크린 컨텍스트 상태의 변경을 수행해서는 안 된다.
3. 'MonitorAppPermission("multiscreen.configuration")'가 허용된 각각의 OCAP 어플리케이션에 대해, 등록된 'MultiScreenConfigurationListener'의 'notify()' 메소드를 호출하고, 상기 생성된 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING'을 인수로써 제공한다.
모든 등록된 리스너는 다음 단계를 계속하기 전에 호출되어야 한다. 그러나 MSM 구현은 다음 단계를 계속하기 이전에 모든 리스너가 'notify()' 메소드로부터 반환되기를 기다릴 필요는 없다.
4. 현재 멀티스크린 설정에 대한 변경의 결과로써 해당 'MultiScreenContext'의 억세스 가능한 상태가 변경되거나 변경될 수 있는 'HScreen' 인스턴스에 대해, (ⅰ) 'HScreen' 인스턴스가 'setMultiScreenConfiguration(..)' 메소드를 호출한 어플리케이션이 아닌 일부 OCAP 어플리케이션에 의해 현재 예약 할당되거나, (ⅱ) 상기 'MultiScreenContext'의 억세스 가능한 상태의 변경이 (OCAP 어플리케이션에 의한 상기 메소드의 명시적인 호출없이) 호스트 디바이스를 초기화하는 변경의 결과인 경우에 OCAP 어플리케이션에 의해 'HScreen' 인스턴스가 예약 할당된다면, 상기 예약 할당된 'HScreen' 인스턴스에 의해 참조된 각각의 'HScreenDevice' 인스턴스에 대해, 생성된 'HScreenDeviceReleasedEvent' 인스턴스들의 통지를 연기하는 동안, 'releaseDevice()' 메소드를 호출하고, 필요한 경우 예약 할당의 주체인 리소스 클라이언트(ResourceClient)의 'release()' 메소드를 호출한다.
5. 현재 멀티스크린 설정에 대한 변경의 결과로써 해당 'MultiScreenConfiguration'의 억세스 가능한 상태가 변경되거나 변경될 수 있는 'HScreenDecive' 인스턴스에 대해, (ⅰ) 'HScreenDevice' 인스턴스가 'setMultiScreenConfiguration(..)' 메소드를 호출한 어플리케이션이 아닌 일부 OCAP 어플리케이션에 의해 현재 예약 할당되거나, (ⅱ) 상기 'MultiScreenConfiguration'의 억세스 가능한 상태의 변경이 (OCAP 어플리케이션에 의한 상기 메소드의 명시적인 호출없이) 호스트 디바이스를 초기화하는 변경의 결과인 경우에, OCAP 어플리케이션에 의해 'HScreenDevice' 인스턴스가 예약 할당된 다면, 상기 'HScreenDevice' 인스턴스에 대해, 생성된 'HScreenDeviceReleasedEvent' 인스턴스의 통지를 연기하는 동안, 'releaseDevice()' 메소드를 호출하고, 필요한 경우 예약 할당의 주체인 'ResourceClient'의 'release()' 메소드를 호출한다.
6. 현재 멀티스크린 설정에 대한 변경의 결과로써 그 'MultiScreenConfiguration'의 억세스 가능한 상태가 변경되거나 변경될 수 있는 'HScreenDecive' 인스턴스에 대해, 해당 'HScreenConfigurationEvent' 인스턴스를 생성한다. 다만 해당 'HScreenConfigurationEvent' 인스턴스 통지는 연기한다.
7. 현재 멀티스크린 설정에 대한 변경의 결과로써 그 'MultiScreenContext'의 억세스 가능한 상태가 변경되거나 변경될 수 있는 'HScreen' 인스턴스에 대해, 해당 'HScreenContextEvent' 인스턴스를 생성한다. 다만 해당 'HScreenContextEvent' 인스턴스 통지는 연기한다.
8. 전술된 단계 3에서 notify() 메소드가 호출된 'MultiScreenConfigurationListener' 인스턴스가 아직 반환되지 않았다면, (ⅰ) 모든 'notify()' 메소드가 반환되거나, (ⅱ) 상기 메소드가 처음 호출된 이후 (실제 시간으로) 최소 5초에서 최대 30초의 기간이 경과하기 전까지 대기한다.
9. 후술되는 사후 조건을 만족하는데 필요한 모든 변경을 수행한다.
10. 상기 생성된 각각의 'HScreenDeviceReleasedEvent' 인스턴스에 대해, 또한 상기 생성된 순서대로 각각의 OCAP 어플리케이션에 대해, 등록된 'ResourceStatusListener'의 'statusChanged()' 메소드가 호출되고, 인자로써 'HScreenDeviceReleasedEvent' 인스턴스가 제공된다.
11. 상기 생성된 각각의 'HScreenConfigurationEvent' 인스턴스에 대해, 또한 상기 생성된 순서대로 각각의 OCAP 어플리케이션에 대해, 등록된 'HScreenConfigurationListener'의 'report()' 메소드가 호출되고, 인자로써 'HScreenConfigurationEvent' 인스턴스가 제공된다.
12. 상기 생성된 각각의 'MultiScreenContextEvent' 인스턴스에 대해, 또한 상기 생성된 순서대로 각각의 OCAP 어플리케이션에 대해, 등록된 'MultiScreenContextListener'의 'notify()' 메소드가 호출되고, 인자로써 MultiScreenContextEvent 인스턴스가 제공된다.
13. 어플리케이션의 결과를 전송하기 위한 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트가 생성된다.
14. 각각의 OCAP 어플리케이션에 대해, 등록된 'MultiScreenConfigurationListener'의 'notify()' 메소드가 호출되고, 인자로써 상기 생성된 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED'를 제공된다.
멀티스크린 설정 변경 단계의 마지막으로, 멀티스크린 설정 변경의 사후 조건이 상술된다.
멀티스크린 설정 변화의 결과로 발생하는 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트에 이어서, 이하의 사후 조건이 순서대로 만족되어야 한다.
1.이하 정의되는 '정지 상태 불변성'이 만족되어야 한다.
2. 현재 멀티스크린 설정은 새로운 설정이다.
3. 새로운 디폴트 스크린은 기존 디폴트 스크린과 동일한 인스턴스(객체)이어야 한다.
4. 디폴트 백그라운드 스크린 디바이스가 기존 멀티스크린 설정 및 새로운 멀티스크린 설정의 두 설정 상의 디폴트 스크린에 존재한다면, 어플리케이션이 'allow_default_device_reconfig' 플래그를 '1'로 설정하지 않는다면,
a. 새로운 디폴트 백그라운드 스크린 디바이스는 기존 디폴트 백그라운드 스크린 디바이스와 동일한 인스턴스이어야 하며,
b. 새로운 디폴트 백그라운드 스크린 디바이스는 기존 디폴트 백그라운드 스크린 디바이스와 동일한 스크린 영역, 픽셀 해상도, 및 픽셀 가로 세로 비(aspect ratio)를 가져야 한다.
어플리케이션이 'allow_default_device_reconfig' 플래그를 '1'로 설정하고, 디폴트 백그라운드 스크린 디바이스가 새로운 멀티스크린 설정이 아닌 기존 멀티스크린 설정 내에 존재한다면, 기존 디폴트 백그라운드 스크린에 대한 참조는 빈 백그라운드 스크린 디바이스와 동일하도록 재설정하여야 한다.
5. 디폴트 비디오 스크린 디바이스가 기존 멀티스크린 설정 및 새로운 멀티스크린 설정의 두 설정 상의 디폴트 스크린 내에 존재한다면, 어플리케이션이 'allow_default_device_reconfig' 플래그를 '1'로 설정하지 않는다면,
a. 새로운 디폴트 비디오 스크린 디바이스는 기존 디폴트 비디오 스크린 디바이스와 동일한 인스턴스이어야 하며,
b. 새로운 디폴트 비디오 스크린 디바이스는 기존 디폴트 비디오 스크린 디바이스와 동일한 스크린 영역, 픽셀 해상도, 및 픽셀 가로 세로 비(aspect ratio)를 가져야 한다.
어플리케이션이 'allow_default_device_reconfig' 플래그를 '1'로 설정하고, 디폴트 비디오 스크린 디바이스가 새로운 멀티스크린 설정이 아닌 기존 멀티스크린 설정 내에 존재한다면, 기존 디폴트 비디오 스크린에 대한 참조는 빈 비디오 스크린 디바이스와 동일하도록 재설정하여야 한다.
6. 디폴트 그래픽 스크린 디바이스가 기존 멀티스크린 설정 및 새로운 멀티스크린 설정 모두의 디폴트 스크린에 존재한다면, 어플리케이션이 'allow_default_device_reconfig' 플래그를 '1'로 설정하지 않는다면,
a. 새로운 디폴트 그래픽 스크린 디바이스는 기존 디폴트 그래픽 스크린 디바이스와 동일한 인스턴스이어야 하며,
b. 새로운 디폴트 그래픽 스크린 디바이스는 기존 디폴트 그래픽 스크린 디바이스와 동일한 스크린 영역, 픽셀 해상도, 및 픽셀 가로 세로 비(aspect ratio)를 가져야 한다.
어플리케이션이 'allow_default_device_reconfig' 플래그를 '1'로 설정하고, 디폴트 그래픽 스크린 디바이스가 새로운 멀티스크린 설정이 아닌 기존 멀티스크린 설정에 존재한다면, 기존 디폴트 그래픽 스크린에 대한 참조는 빈 그래픽 스크린 디바이스와 동일하도록 재설정하여야 한다.
7. 재설정(reconfiguration) 이전에 획득된 모든 넌-디폴트 스크린 참조가 더 이상 넌-디폴트 스크린이 아니라면, 빈 스크린과 동일하여야 한다. 상기 넌-디폴트 스크린 참조가 넌-디폴트 스크린이라면, 빈 스크린과 동일하면 안 된다.
8. 재설정(reconfiguration) 이전에 획득된 모든 넌-디폴트 스크린 디바이스 참조가 더 이상 넌-디폴트 스크린 디바이스가 아니라면, 빈 스크린 디바이스와 동일하여야 한다. 상기 넌-디폴트 스크린 디바이스 참조가 넌-디폴트 스크린 디바이스라면, 빈 스크린 디바이스와 동일해서는 안 된다.
이하, '정지 상태 불변성'이 정의된다.
'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 발생 이전 및 해당 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트 발생 이후에는, 후술되는 불변성이 순서대로 준수되어야 한다.
1. 변경 중이 아닌(non-changing) 현재 멀티스크린 매니저가 있어야 한다.
2. 변경 중이 아닌 현재 플랫폼별 멀티스크린 설정이 있어야 한다.
3. 각각의 디스플레이 스크린마다 현재 변경 중이 아닌 디스플레이별 멀티스크린 설정이 있어야 한다.
4. 억세스 가능한 멀티스크린 설정들 중 변경 중이 아니며 비지 않은(non-empty) 멀티스크린 설정들이 있어야 한다.
5. 현재 플랫폼별 멀티스크린 설정은 (권한을 가진 고유 어플리케이션에 대해) 억세스 가능한 설정이어야 한다.
6. 각각의 현재 디스플레이별 멀티스크린 설정은 (권한을 가진 고유 어플리케이션에 대해) 억세스 가능한 설정이어야 한다.
7. 현재 플랫폼별 멀티스크린 설정 상의 스크린들 중 변경 중이 아닌 비지 않은(non-empty) 스크린들이 있어야 한다.
8. 각각의 현재 플랫폼별 멀티스크린 설정 상의 스크린들 중 변경 중이 아닌 비지 않은(non-empty) 스크린들이 있어야 한다.
9. 현재 플랫폼별 멀티스크린 설정의 스크린들은 비지 않아야 한다.
10. 각각의 현재 디스플레이별 멀티스크린 설정의 스크린들은 비지 않아야 한다.
11. 현재 멀티스크린 설정 상의 별개의 두 스크린 엔트리는 동일한 리소스를 나타내서는 안 된다.
12. 현재 디폴트 스크린이 있어야 한다.
13. 현재 디폴트 스크린은 빈 스크린과 동일해서는 안 된다.
14. 일부 현재 멀티스크린 설정의 단 하나의 스크린 엔트리는 디폴트 스크린과 동일한 리소스를 나타내야 한다.
15. 억세스 가능한 스크린 중 비지 않은 스크린이 있어야 한다.
16. 현재 디폴트 스크린은 억세스 가능한 스크린 중 별개의 스크린여야 한다.
17. 현재 디폴트 스크린의 백그라운드 스크린 디바이스는 빈 백그라운드 스크린 디바이스와 동일해서는 안 된다.
18. 현재 디폴트 스크린의 비디오 스크린 디바이스는 빈 비디오 스크린 디바이스와 동일해서는 안 된다.
19. 현재 디폴트 스크린의 그래픽 스크린 디바이스는 빈 그래픽 스크린 디바이스와 동일해서는 안 된다.
이하, '동적 상태 불변성'이 정의된다.
'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 발생 이후 및 해당 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트 발생 전에, 후술되는 불변성이 순서대로 준수되어야 한다.
1. 변경 중이 아닌 현재 멀티스크린 매니저가 있어야 한다.
2. 변경 가능성이 있는 현재 멀티스크린 설정이 있어야 한다.
3. 억세스 가능한 멀티스크린 설정들 중 변경 가능성이 있으며 비지 않은 멀티스크린 설정들이 있어야 한다.
4. 현재 멀티스크린 설정은 억세스 가능한 설정이어야 한다.
5. 현재 멀티스크린 설정 상의 스크린들 중 변경 가능성이 있는 비지 않은 스크린들이 있어야 한다.
6. 현재 멀티스크린 설정 상의 스크린은 비지 않아야 한다.
7. 현재 멀티스크린 설정 상의 별개의 두 스크린 엔트리는 동일한 리소스를 나타내서는 안 된다.
8. 변경 가능성이 있는 현재 디폴트 스크린이 있어야 한다.
9. 현재 디폴트 스크린은 빈 스크린과 동일하면 안 된다.
10. 현재 멀티스크린 설정 상의 단 하나의 스크린 엔트리가 디폴트 엔트리와 동일한 리소스를 나타내야 한다.
11. 억세스 가능한 스크린 중 변경 가능성이 있는 비지 않은 스크린이 있어야 한다.
12. 현재 디폴트 스크린은 억세스 가능한 스크린들 중 별개의 스크린이어야 한다.
13. 현재 디폴트 스크린의 백그라운드 스크린 디바이스는 빈 백그라운드 스크린 디바이스와 동일하면 안 된다.
14. 현재 디폴트 스크린의 비디오 스크린 디바이스는 빈 비디오 스크린 디바이스와 동일하면 안 된다.
15. 현재 디폴트 스크린의 그래픽 스크린 디바이스는 빈 그래픽 스크린 디바이스와 동일하면 안 된다.
이하, 본 발명이 적용되는 기본적인 HAVi 모델 익스텐션이 상술된다.
멀티플 스크린 매니저는 소정 작동이 가능하게 하고 사용법을 기본적인 HAVi 모델, 특히 'HScreen', 'HScreenDevice', 'HScreenConfiguration', 'HScreenConfigTemplate', 'HVideoDevice' 타입이 정의되는 HAVi로 확장시킨다.
전술된 바와 같이, 각각의 'HScreen 인스턴스'는, 멀티플 스크린 매니저에 의해 정의된 대로 디스플레이 스크린 또는 로지컬 스크린으로 특징지어진다.
디스플레이 스크린 또는 로지컬 스크린으로 특징지어지는 'HScreen' 인스턴스의 차이점은 'HScreen' 인스턴스 및 상기 'HScreen' 인스턴스에 의해 나타내지는 기저 리소스에 대한 멀티플 스크린 매니저에 의해 만들어진다. 특히, 이하의 'HScreen' 인스턴스와 연관된 기저 상태는 시간에 따라 변경될 수 있다.
즉, 기저 백그라운드 스크린 디바이스의 개수, 상기 기저 백그라운드 스크린 디바이스의 스크린 디바이스 설정(파라미터들), 디폴트 'HBackgroundDevice' 인스턴스와 연관된 기저 백그라운드 스크린 디바이스, 기저 비디오 스크린 디바이스의 개수, 상기 기저 비디오 스크린 디바이스의 스크린 디바이스 설정(파라미터들), 디폴트 'HVideoDevice' 인스턴스와 연관된 기저 비디오 스크린 디바이스, 기저 그래픽 스크린 디바이스의 개수, 디폴트 'HGraphicsDevice' 인스턴스와 연관된 기저 그래픽 스크린 디바이스, 상기 기저 그래픽 스크린 디바이스의 스크린 디바이스 설정(파라미터들)이 시간에 따라 변경될 수 있다.
각각의 'HScreen' 인스턴스는 'MultiScreenContext' 인터페이스를 구현하거나, 'HScreen' 인스턴스가 'MultiScreenConfigurableContext' 인터페이스에 의해 정의되는 기능성에 따라 설정될 수 있는 기저 스크린 리소스를 가리킨다면, 'HScreen' 인스턴스는 'MultiScreenContext' 인터페이스 대신에 'MultiScreenConfigurableContext' 인터페이스를 구현하여야 한다.('MultiScreenConfigurableContext' 인터페이스가 'MultiScreenContext' 인터페이스의 서브인터페이스이다.)
'HScreen.getHScreens()' 스태틱 메소드(static method)는 'MultiScreenManager.getInstance().getScreens()' 메소드와 동일한 값을 반환하여야 한다.
'HScreen.getDefaultHScreen()' 스태틱 메소드는 'MultiScreenManager.getInstance().getDefaultScreen()' 메소드와 동일한 값을 반환하여야 한다.
이하, 디폴트 'HScreen'를 지정하는 방식이 상술된다.
어플리케이션이 최초로 시작될 때, 어플리케이션은 우선, 'HScreen.getHScreens()' 메소드에 의해 반환될 억세스 가능한 스크린들과 연관되어야 하고, 둘째로 이하의 규칙에 따라 디폴트 HScreen에 지정되어야 한다. 이하의 규칙은 첫번 째 규칙이 준수된다면, 나머지는 무시된다.
1. 'ServiceContext', SC,의 선택된 Service에서 어플리케이션으로 시그널링되고, 상기 'ServiceContext'는 오직 하나의 스크린(또는 기저 스크린)과 연관된다면, 그 스크린을 디폴트 스크린으로 사용한다.
2. 그렇지 않으면, SC가 복수 개의 스크린( 또는 복수 개의 기저 스크린)과 연관되고, 이 스크린들 중 하나가 메인 스크린으로 분류된다면, 즉 'getScreenCategory()' 메소드가 'MultiScreenConfiguration.SCREEN_CATEGORY_MAIN' 값을 반환한다면, 'HScreen.getHScreens()' 메소드에 의해 반환되는 스크린의 어레이 중 나타나는 최초의 메인 스크린을 디폴트 스크린으로 사용한다.
3. SC가 메인 스크린이 아닌 복수 개의 스크린에 연관된다면, 'HScreen.getHScreens()' 메소드에 의해 반환되는 스크린의 어레이 중 나타나는 최초의 스크린을 디폴트 스크린으로 사용한다.
MSM는 '빈(empty) HScreen'으로 알려진, 특별히 정의된 'HScreen' 인스턴스를 도입하며, '빈 HScreen'는, (명목상으로는 비지 않은) 'HScreen' 인스턴스 중에서 잘 정의된 알려진 상태를 설정하기 위해 사용되는 'HScreen' 클래스 (또는 'HScreen' 클래스의 서브 클래스)의 고유 불변의 인스턴스이다.
빈 'HScreen'(이하 ES라 함.)는 후술되는 제한 조건을 만족해야 한다.
1. 어플리케이션의 참조 범위 내에서, ES는 고유 (객체) 인스턴스이다;
2. ES는 'MultiScreenContext, MultiScreenConfigurableContext' 인터페이스, 'ResourceProxy' 인터페이스, 및 'ResourceServer' 인터페이스를 구현한다;
3. 'ES.getDefaultHBackgroundDevice()' 메소드는 그 상태가 이하 정의되는 빈 'HBackgroundDevice'와 동일한 'HBackgroundDevice'를 반환하여야 한다;
4. 'ES.getDefaultHVideoDevice()' 메소드는 그 상태가 이하 정의되는 빈 'HVideoDevice'와 동일한 'HVideoDevice'를 반환하여야 한다;
5. 'ES.getDefaultHGraphicsDevice()' 메소드는 그 상태가 이하 정의되는 빈 'HGraphicsDevice'와 동일한 'HGraphicsDevice'를 반환하여야 한다;
6. 'ES.getBestConfiguration(HBackgroundConfigTemplate hbc)' 메소드는 'ES.getDefaultBackgroundDevice().getBestConfiguration(hbc)'를 반환하여야 한다;
7. 'ES.getBestConfiguration(HVideoConfigTemplate hvc)' 메소드는 'ES.getDefaultVideoDevice().getBestConfiguration(hvc)'를 반환하여야 한다;
8. 'ES.getBestConfiguration(HGraphicsConfigTemplate hgc)' 메소드는 'ES.getDefaultGraphicsDevice().getBestConfiguration(hgc)'를 반환하여야 한다;
9. 'ES.getBackgroundDevices()' 메소드는 'new HBackgroundDevice[1]ES.getDefaultHBackgroundDevice()'를 반환하여야 한다;
10. 'ES.getVideoDevices()' 메소드는 'new HVideoDevice[1]ES.getDefaultHVideoDevice()'를 반환하여야 한다;
11. 'ES.getGraphicsDevices()' 메소드는 'new HGraphicsDevice[1]ES.getDefaultHGraphicsDevice()'를 반환하여야 한다;
12. 'ES.getCoherentScreenConfigurations(..)' 메소드는 'null' 값을 반환하여야 한다;
13. 'ES.setCoherentScreenConfigurations(..)' 메소드는 'HConfigurationException'을 발생시켜야 한다;
14. '((MultiScreenContext)ES).getScreenType()' 메소드는 'MultiScreenContext.SCREEN_TYPE_LOGICAL'를 반환하여야 한다;
15. '((MultiScreenContext)ES).getDisplayScreen()' 메소드는 'null' 값을 반환하여야 한다;
16. '((MultiScreenContext)ES).getDisplayArea()' 메소드는 'null' 값을 반 환하여야 한다;
17. '((MultiScreenContext)ES).getOutPorts()' 메소드는 'null' 값을 반환하여야 한다;
18. '((MultiScreenContext)ES).getServiceContexts()' 메소드는 'new ServiceContext[0]'을 반환하여야 한다;
19. '((MultiScreenContext)ES).getVisible()' 메소드는 '거짓' 값을 반환하여야 한다;
20. '((MultiScreenContext)ES).getZOrder()' 메소드는 '-1' 값을 반환하여야 한다;'
21. '((MultiScreenContext)ES).addScreenContextListener()' 메소드는 어떤 반응도 있어서는 안 된다.;
22. '((MultiScreenConfigurableContext)ES).setDisplayScreen(..)' 메소드는 'SecurityException'가 적용되지 않는다면, 'IllegalStateException'를 발생시켜야 한다;
23. '((MultiScreenConfigurableContext)ES).setDisplayArea(..)' 메소드는 'SecurityException'가 적용되지 않는다면, 'IllegalStateException'를 발생시켜야 한다;
24. '((MultiScreenConfigurableContext)ES).setVisible(..)' 메소드는 'SecurityException'가 적용되지 않는다면, 'IllegalStateException'를 발생시켜야 한다;
25. '((MultiScreenConfigurableContext)ES).setZOrder(..)' 메소드는 'SecurityException'가 적용되지 않는다면, 'IllegalStateException'를 발생시켜야 한다;
26.'((MultiScreenConfigurableContext)ES).addOutputPort(..)' 메소드는 'SecurityException'가 적용되지 않는다면, 'IllegalStateException'를 발생시켜야 한다;
27. '((MultiScreenConfigurableContext)ES).addServiceContext(..)' 메소드는 'SecurityException'가 적용되지 않는다면, 'IllegalStateException'를 발생시켜야 한다;
28. '((ResourceProxy)ES).getClient()' 메소드는 'null' 값을 반환하여야 한다.
두 개의 'HScreenDevice 인스턴스', SD1 및 SD2,의 기저 리소스들이 동일하다면, 즉 'sameResources(SD1,SD2)'가 '참' 값을 반환한다면, 'SD1.getIDstring()' 메소드는 'SD2.getIDstring()' 메소드와 동일한 값을 반환하여야 한다. SD1 및 SD2의 기저 리소스가 동일하지 않다면, 'SD1.getIDstring()'는 'SD2.getIDstring()'과 동일한 값을 반환하면 안 된다.
OCAP 어플리케이션이, 현재 활성화된 멀티스크린 설정에 의해 참조되는 기저 스크린 디바이스 리소스들 내에 전부 포함된 기저 스크린 디바이스 리소스에 대한 'HScreenDevice'를 예약 할당하면, 'HPermissionDeniedException'가 발생된다.
상기 제한 조건은, 리소스가 일부 현재 활성화된 멀티스크린 설정에 의해 나 타내지는 기저 리소스들에 포함되지 않는 경우, 어플리케이션이 스크린 디바이스 리소스를 예약 할당하는 것을 방지하기 위함이다. 이러한 상황은 스크린 디바이스 리소스가 활성화된 멀티스크린 설정 및 일부 비활성화된 멀티스크린 설정으로 구별되는 경우에 적용된다.
이하, 디폴트 스크린 디바이스들의 지정(default screen devices assignment) 방식이 상술된다.
억세스 가능한 스크린 디바이스 중 디폴트 스크린 디바이스들은, 전술된 대로 디폴트 스크린을 지정함으로써 어플리케이션에 지정된다. 'HScreen', S,에의 디폴트 지정에 있어서, 어플리케이션에 지정된 디폴트 스크린 디바이스들은 'S.getDefaultHBackgroundDevice()', 'S.getDefaultHVideoDevice()', 및 'S.getDefaultHGraphicsDevice()'에 의해 결정되어야 한다.
디폴트 스크린이 소정 타입의 둘 이상의 스크린 디바이스를 포함한다면, 상기 스크린 디바이스들 중 어느 스크린 디바이스가 상기 스크린을 위한 소정 타입의 디폴트 스크린 디바이스인지 여부를 결정하기 위한 프로세스는 플랫폼에 의존적이어야 하며, 호환 가능한 어플리케이션은 상기 지정 프로세스에 의존하면 안 된다.
MSM는 정의된 서브 타입, 즉 'HBackgroundDevice', 'HVideoDevice', 및 'HGraphicsDevice',의 '빈 HScreenDevice 인스턴스'라는 특별히 정의된 스크린 디바이스를 도입한다. 빈 'HScreenDevice' 인스턴스(이하 'ED'라 함.)는 다음의 작은 표제 하에 정의되는 서브 타입의 세부 제한 조건과 함께, 후술되는 제한 조건을 만족해야 한다.
1. 'ED.getIDString()' 메소드는 빈 스트링 " "을 반환하여야 한다;
2. 'ED.getScreenAspectRatio()' 메소드는 'new Dimension()' 메소드와 동일한 값을 반환하여야 한다;
3. 'ED.addMultiScreenConfigurationListener(..)' 메소드는 반응해서는 안 된다.;
4. 'ED.reserveDevice(ResourceClient)' 메소드는 '거짓' 값을 반환하면 안 된다;
5. 'ED.releaseDevice()' 메소드는 반응하면 안 된다.;
6. 'ED.getClient()' 메소드는 'null' 값을 반환하여야 한다.
'빈 HBackgroundDevice(이하 'EBD'라 함)'은 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 범위 내에서, 'EBD'는 고유 인스턴스 (또는 고유 객체 인스턴스)이다;
2. 'EBD'는 상기 빈 'HScreenDevice' 인스턴스에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EBD.getDefaultConfiguration()' 메소드는 이하 정의되는 빈 'HBackgroundConfiguration'를 반환하여야 한다;
4. 'EBD.getCurrentConfiguration()' 메소드는 'EBD.getDefaultConfiguration()' 메소드와 동일한 값을 반환하여야 한다;
5. 'EBD.getBestConfiguration()' 메소드는 'EBD.getDefaultConfiguration()' 메소드와 동일한 값을 반환하여야 한다;
6. 'EBD.getConfigurations()' 메소드는 'new HBackgroundConfiguration[1]getDefaultConfiguration()' 메소드와 동일한 값을 반환하여야 한다.
7. 'EBD.setBackgroundConfiguration()' 메소드는, 'SecurityException' 또는 'HPermissionDeniedException'이 적용되지 않는다면, 'HConfigurationException'를 발생시켜야 한다.
'빈 HvideoDevice(이하, 'EVD'라 함.)'은 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 관점에서, 'EVD'는 고유 인스턴스 (또는 고유 객체 인스턴스)이다;
2. 'EVD'는 상기 빈 'HScreenDevice'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EVD.getDefaultConfiguration()' 메소드는 이하 정의되는 빈 'HvideoConfiguration'를 반환하여야 한다;
4. 'EVD.getCurrentConfiguration()' 메소드는 'EVD.getDefaultConfiguration()' 메소드와 동일한 값을 반환하여야 한다;
5. 'EVD.getBestConfiguration()' 메소드는 'EVD.getDefaultConfiguration()' 메소드와 동일한 값을 반환하여야 한다;
6. 'EVD.getConfigurations()' 메소드는 new 'HvideoConfiguration[1]getDefaultConfiguration()' 메소드와 동일한 값을 반환하여야 한다.
7. 'EVD.setVideoConfiguration()' 메소드는, 'SecurityException' 또는 'HpermissionDeniedException'이 적용되지 않는다면, 'HconfigurationException'를 발생시켜야 한다.
'빈 HGraphicsDevice(이하, 'EGD'라 함.)'은 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 관점에서, 'EGD는 고유 (객체) 인스턴스이다;
2. 'EGD'는 상기 빈 ''HScreenDevie'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EGD.getDefaultConfiguration()' 메소드는 이하 정의되는 빈 'HGraphicsConfiguration'를 반환하여야 한다;
4. 'EGD.getCurrentConfiguration()' 메소드는 'EGD.getDefaultConfiguration()'와 동일한 값을 반환하여야 한다;
5. 'EGD.getBestConfiguration()' 메소드는 'EGD.getDefaultConfiguration()'와 동일한 값을 반환하여야 한다;
6. 'EGD.getConfigurations()' 메소드는 'new HGraphicsConfiguration[1]getDefaultConfiguration()' 메소드와 동일한 값을 반환하여야 한다.
7. 'EGD.setGraphicsConfiguration()' 메소드는, 'SecurityException' 또는 'HPermissionDeniedException'이 적용되지 않는다면, 'HConfigurationException'를 발생시켜야 한다.
MSM는 정의된 서브 타입, 즉 'HBackgroundConfiguration', 'HVideoConfiguration', 및 'HGraphicsConfiguration',의 빈 'HScreenConfiguration' 인스턴스라는 특별히 정의된 스크린 설정을 도입한다.
'빈 HScreenConfiguration' 인스턴스(이하 'EC'라 함.)는 다음의 작은 표제 하에 정의된 서브타입의 세부 제한 조건과 함께 후술되는 제한 조건을 만족하여야 한다.
1. 'EC.convertTo(..)' 메소드는 'null' 값을 반환하여야 한다;
2. 'EC.getFlickerFilter()' 메소드는 '거짓' 값을 반환하여야 한다;
3. 'EC.getInterlaced()' 메소드는 '거짓' 값을 반환하여야 한다;
4. 'EC.getOffset(..)' 메소드는 'new Dimension()'를 반환하여야 한다;
5. 'EC.getPixelAspectRatio()' 메소드는 'new Dimension()'를 반환하여야 한다;
6. 'EC.getPixelResolution()' 메소드는 'new Dimension()'를 반환하여야 한다;
7. 'EC.getScreenArea()' 메소드는 'new HScreenRectangle(0,0,0,0)'를 반환하여야 한다.
'빈 HBackgroundConfiguration'의 인스턴스(이하 'EBC'라 함.)는 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 범위 내에서, 'EBC' 는 고유 인스턴스 (또는 고유 객체 인스턴스)이다;
2. 'EBC'는 상기 빈 'HScreenConfiguration'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EBC.getDevice()'는 상기 정의된 빈 'HBackgroundDevice' 인스턴스를 반환하여야 한다;
4. 'EBC. getConfigTemplate(..)'는 이하 정의되는 빈 'HBackgroundConfigTemplate'를 반환하여야 한다;
5. 'EBC.getColor()'는 'new color(0,0,0)'를 반환하여야 한다;
6. 'EBC.setColor()'는 'HConfigurationException'를 발생시켜야 한다.
'빈 HVideoConfiguration'의 인스턴스(이하 'EVC'라 함.)는 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 범위 내에서, 'EVC'는 고유 인스턴스 (또는 객체 인스턴스)이다;
2. 'EVC'는 상기 빈 'HScreenConfiguration'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EVC.getDevice()' 메소드는 상기 정의된 빈 'HVideoDevice' 인스턴스를 반환하여야 한다;
4. 'EVC.getConfigTemplate(..)' 메소드는 이하 정의되는 빈 'HVideoConfigTemplate'를 반환하여야 한다.
'빈 HGraphicsConfiguration'의 인스턴스(이하 'EGC'라 함.)는 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 범위 내에서, 'EGC'는 고유 (객체) 인스턴스이다;
2. 'EGC'는 상기 빈 'HScreenConfiguration'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EGC.getDevice()' 메소드는 상기 정의된 빈 'HGraphicsDevice' 인스턴스를 반환하여야 한다;
4. 'EGC.getConfigTemplate(..)' 메소드는 이하 정의되는 빈 HGraphicsConfigTemplate를 반환하여야 한다;
5. 'EGC.getAllFonts()' 메소드는 'new Font[0]'를 반환하여야 한다;
6. 'EGC.getCompatibleImage(Image input, HImageHints hints)' 메소드는 'input'을 반환하여야 한다;
7. 'EGC.getComponentHScreenRectangle(..)' 메소드는 'null' 값을 반환하여야 한다;
8. 'EGC.getPixelCoordinatesHScreenRectangle(..)' 메소드는 'new Rectangle()'을 반환하여야 한다;
9. 'EGC.getPunchThroughToBackgroundColor(..)' 메소드는 'null' 값을 반환하여야 한다;
10. 'EGC.dispose(Color)' 메소드는 반응하면 안 된다.
MSM는 이하 정의된 서브 타입, 즉 'HBackgroundConfigTemplate', 'HVideoConfigTemplate', 및 'HGraphicsConfigTemplate',의 '빈 HScreenConfigTemplate' 인스턴스라는 특별히 정의된 스크린 설정 템플릿를 도입한다.
'빈 HScreenConfigTemplate'의 인스턴스(이하 'ET'라 함.)는 다음의 작은 표제 하에 정의된 서브타입의 세부 제한 조건과 함께 후술되는 제한 조건을 만족하여야 한다.
1. 'ET.getPreferenceObject(int)' 메소드는 'IllegalArgumentException'를 발생시켜야 한다;
2. 'ET.getPreferencePriority(int)' 메소드는 'HScreenConfigTemplate.DONT_CARE'를 반환하여야 한다;
3. 'ET.setPreference(int,int)' 메소드는 'IllegalArgumentException'를 발생시켜야 한다;
4. 'ET.setPreference(int,Object,int)' 메소드는 'IllegalArgumentException'를 발생시켜야 한다;
'빈 HBackgroundConfigTemplate'의 인스턴스(이하 'EBT'라 함.)는 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 범위 내에서, 'EBT'는 고유 (객체) 인스턴스이다;
2. 'EBT'는 상기 빈 'HScreenConfigTemplate'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EBT.isConfigSupported(HBackgroundConfiguration)' 메소드는 '거짓' 값 을 반환하여야 한다.
'빈 HVideoConfigTemplate'의 인스턴스(이하 'EVT'라 함.)는 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 범위 내에서, 'EVT'는 고유 (객체) 인스턴스이다;
2. 'EVT'는 상기 빈 'HScreenConfigTemplate'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EVT.isConfigSupported(HVideoConfiguration)' 메소드는 '거짓' 값을 반환하여야 한다.
'빈 HGraphicsConfigTemplate'의 인스턴스(이하 'EGT'라 함.)는 후술되는 제한 조건을 만족하여야 한다.
1. 어플리케이션의 참조의 범위 내에서, 'EGT'는 고유 (객체) 인스턴스이다;
2. 'EGT'는 상기 빈 'HScreenConfigTemplate'에 대해 상술된 제한 조건을 만족하여야 한다;
3. 'EGT.isConfigSupported(HGraphicsConfiguration)' 메소드는 '거짓' 값을 반환하여야 한다.
이하, 비디오 디바이스('HVideoDevice')에 대한 개념이 상술된다.
본 명세서에 의해 정의된 일부 메커니즘의 사용이 (최소한 비디오 디코더와 디코더 포맷 변환 설정부를 포함하는) 둘 이상의 비디오 파이프라인이 'HVideoDevice' 인스턴스에 의해 나타내지는 기저 비디오 스크린 디바이스 리소스들과 연관(맵핑)할 수 있도록 허용한다면, 파이프라인 중 하나는 현재 작업에 관여 하는(contributing) 비디오 파이프라인으로 지명되고, 나머지 파이프라인은 관여하지 않는(non-contributing) 비디오 파이프라인으로 지명된다. 관여하지 않는 비디오 파이프라인은 'HVideoDevice' 인스턴스에 의해 표현되는 기저 비디오 스크린 디바이스 리소스들에 대해 비디오 정보 또는 관련 오디오 정보를 제공해서는 안 된다.
관여하는 비디오 파이프라인은 후술되는 규칙의 순서에 따라 잠재적으로 관여하는 비디오 파이프라인의 그룹으로부터 결정된다.
1. 후보 비디오 파이프라인들 중 단 하나의 비디오 파이프라인이 일부 비추상(non-abstract) 서비스의 활성화된 비디오 기초 스트림과 연관된다면, 상기 비디오 파이프라인이 관여하는 파이프라인이다;
2. 아니면, 후보 비디오 파이프라인 중 둘 이상의 비디오 파이프라인이 일부 비추상(non-abstract) 서비스의 활성화된 비디오 기초 스트림과 연관된다면, 가장 최근에 선택된 비추상 서비스의 비디오 파이프라인이 관여하는 파이프라인이다;
3. 아니면, 후보 비디오 파이프라인 중 단 하나의 비디오 파이프라인이 일부 비추상(non-abstract) 서비스에 의해 조정되는 미디어 플레이어와 연관된다면, 상기 미디어 플레이어의 비디오 파이프라인이 관여하는 파이프라인이다;
4. 아니면, 후보 비디오 파이프라인 중 둘 이상의 비디오 파이프라인이 일부 비추상(non-abstract) 서비스에 의해 조정되는 미디어 플레이어와 연관된다면, 가장 최근에 시작된(또는 중단 또는 정지된 이후 재개된) 미디어 플레이어의 비디오 파이프라인이 관여하는 파이프라인이다;
5. 아니면, 후보 비디오 파이프라인 중 단 하나의 비디오 파이프라인이 일부 추상(abstract) 서비스에 의해 조정되는 미디어 플레이어와 연관된다면, 상기 미디어 플레이어의 비디오 파이프라인이 관여하는 파이프라인이다;
6. 아니면, 후보 비디오 파이프라인 중 둘 이상의 비디오 파이프라인이 일부 추상(abstract) 서비스에 의해 조정되는 미디어 플레이어와 연관된다면, 가장 최근에 시작된(또는 중단 또는 정지된 이후 재개된) 미디어 플레이어의 비디오 파이프라인이 관여하는 파이프라인이다;
7. 아니면, 어느 비디오 파이프라인이 관여하는 파이프라인인지의 결정은 본 명세서에서 정의되지 않으며, 구현 방식에 의존된다.
이하, 본 발명의 일 실시예가 OCAP MSM 익스텐션을 구현하는 OCAP 호스트 디바이스를 기반으로 할 때, Xlet 어플리케이션의 보안성(security)를 위해 필요한 일부 허가 방식이 상술된다.
본 명세서에서 정의된 소정 메소드를 호출하기 위해서는, 어플리케이션이 'MonitorAppPermission("multiscreen.configuration")' 또는/및 'MonitorAppPermission("multiscreen.context")'을 가져야 한다. OCAP MSM 익스텐션을 구현하는 OCAP 호스트 디바이스는, 후술되는 부가적인 허가가 'MonitorAppPermission'에 주어진다고 간주된다.
'multiscreen.configuration' 허가는 플랫폼 멀티스크린 설정 상태에 억세스하고 변경하기 위한 기능을 제공할 수 있는지 여부에 대한 허가이다. 'multiscreen.configuration' 허가가 주어진 어플리케이션은 플랫폼의 멀티스크린 설정을 변경하고, 그 동적 상태를 판별하고 감시할 수 있다.
'multiscreen.context'는 스크린의 멀티스크린 컨텍스트 상태를 변경하기 위한 기능을 제공할 수 있는지 여부에 대한 허가이다. 'multiscreen.context' 허가가 주어진 어플리케이션은 억세스 가능한 스크린들의 멀티스크린 컨텍스트 상태를 변경할 수 있다.
또한, PRF(Permission Request File)의 DTD(Document Type Definition)에 의해 정의된 'ocap:monitorapplication' 요소 타입의 'name' 속성의 열거된 표시 값 타입은 'multiscreen.configuration' 및 'multiscreen.context'의 값을 포함한다고 간주되어야 한다.
본 발명의 일 실시예는 자바 시스템을 기반으로 하므로, 이하 자바 시스템 프로퍼티가 정의된다.
본 발명의 일 실시예에서, OCAP 호스트 디바이스가 MSM 익스텐션을 구현한다면, "ocap.api.option.msm" 자바 시스템 프로퍼티는 본 발명이 구현된 '버전 1.0.0(version(1.0.0))'에 따르는 값으로 정의되어야 한다. 반대로, 호스트 디바이스가 "ocap.api.option.msm" 자바 시스템 프로퍼티를 정의한다면, 호스트 디바이스는 상기 프로퍼티의 값에 관련된 '버전 1.0.0(version(1.0.0))'을 구현하여야 한다.
본 프로퍼티에 대한 읽기 억세스 권한은 서명된 어플리케이션 및 서명되지 않은 어플리케이션 모두에게 부여된다.
이하, 본 발명의 일 실시예에 따라 Java 시스템 기반의 멀티스크린 매니저를 구현하기 위한 실시예들이 상술된다.
먼저, 도 11a 내지 11g를 참고하여 본 발명의 일 실시예에 따른 자바 인터페이스의 상수 레지스트리가 상술된다.
도 11a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.MultiScreenConfigurableContext' 에서의 자바 상수 레지스트리를 도시한다. 각각의 상수는 도 13a 내지 13f 를 참고하여 후술될 org.ocap.ui 패키지(package)의 'MultiScreenConfigurableContext' 인터페이스 상에서 정의된다.
도 11b 은 본 발명의 일 실시예에 따른 'org.ocap.ui.MultiScreenConfiguration' 에서의 자바 상수 레지스트리를 도시한다. 각각의 상수는 도 14a 내지 14c 를 참고하여 후술될 'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스 상에서 정의된다.
도 11c 은 본 발명의 일 실시예에 따른 'org.ocap.ui.MultiScreenContext' 상의 자바 상수 레지스트리를 도시한다. 각각의 상수는 도 15a 내지 15d 를 참고하여 후술될 'org.ocap.ui' 패키지의 'MultiScreenContext' 인터페이스 상에서 정의된다.
도 11d 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenConfigurationEvent' 상의 자바 상수 레지스트리를 도시한다. 각각의 상수는 도 18a 내지 18d 를 참고하여 후술될 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 인터페이스 상에서 정의된다.
도 11e 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenContextEvent' 상의 자바 상수 레지스트리를 도시한다. 각각의 상수는 도 20a 내지 20d 를 참고하여 후술될 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 인터페이스 상에서 정의된다.
도 11f 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenEvent' 상의 자바 상수 레지스트리를 도시한다. 각각의 상수는 도 22a 내지 22d 를 참고하여 후술될 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 인터페이스 상에서 정의된다.
도 11g 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenResourceEvent' 상의 자바 상수 레지스트리를 도시한다. 각각의 상수는 도 23a 내지 23d 를 참고하여 후술될 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 인터페이스 상에서 정의된다.
이하, 본 발명의 일 실시예에 따른 멀티스크린 매니지먼트을 위한 플랫폼 동작(시맨틱)이 상술된다.
이하, 도 12 내지 16f 를 참고하여, HAVi 사용자 인터페이스의 'org.ocap.ui' 패키지에 대한 확장형의 일 실시예가 상술된다.
도 12 는 본 발명의 일 실시예에 따른 자바 패키지 'org.ocap.ui'의 인터페 이스 및 클래스를 도시한다.
'org.ocap.ui' 패키지의 인터페이스(1200)는, 'MultiScreenConfigurableContext' 인터페이스(1210), 'MultiScreenConfiguration' 인터페이스(1220) 및 'MultiScreenContext' 인터페이스(1230)를 포함한다.
'MultiScreenConfigurableContext' 인터페이스(1210)는 이하 도 13a 내지 도 13f 를 참고하여, 'MultiScreenConfiguration' 인터페이스(1220)는 이하 도 14a 내지 14c 를 참고하여, 'MultiScreenContext' 인터페이스(1230)는 이하 도 15a 내지 15d 를 참고하여 상술된다.
'org.ocap.ui' 패키지의 클래스(1250)는 'MultiScreenManager' 클래스(1260)를 포함한다. 'MultiScreenManager' 클래스(1260)는 이하 도 16a 내지 16f 를 참고하여 상술된다.
도 13a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfigurableContext' 인터페이스의 정의를 도시한다.
'MultiScreenConfigurableContext' 인터페이스(1210)는 슈퍼인터페이스(Superinterface)로 'MultiScreenContext', 'org.davic.resources.ResourceProxy'가 존재하며, 'public interface MultiScreenConfigurableContext'로 선언되고, 'extends MultiScreenContext, org.davic.resources.ResourceProxy'로 확장된다.
'MultiScreenConfigurableContext' 인터페이스(1210)는 이하를 수행하기 위한 툴들을 제공한다.
1. 로지컬 'HScreen'이 재생되는 디스플레이 'HScreen'의 영역, 가시성, (다른 'HSreen'들 사이의) 'z-order'를 포함하는 로지컬 'HScreen'들이 디스플레이 'HScreen'들에 맵핑 관계의 변경;
2. 'HScreen' 내의 'HScreenDevice'들의 'z-order'의 변경;
3. 'HScreen'와 연관된 'ServiceContext'들의 변경;
4. 디스플레이 'HScreen'들과 해당 'VideoOutPort' 인스턴스들의 연관 관계의 변경;
5. 그 생성된 오디오가 'HScreen'의 오디오 소스들을 설정하는 'HScreenDevice'들의 변경;
6. 디스플레이 'HScreen'의 현재 오디오 포커스 지정의 변경;
7. 기저 스크린 및 기저 스크린 디바이스 리소스의 예약 할당 및 예약 할당의 해제;
8. 기저 스크린 및 그 기저 스크린 다바이스 리소스를 예약 할당했던 현재 리소스 클라이언트에 대한 참조를 획득;
9. 디스플레이 'HScreen'의 현재 활성화된 디스플레이별 멀티스크린 설정을 설정.
'HScreen' 인스턴스가 OCAP 어플리케이션에 사용되고, 'HScreen'이 'MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 기능성과 관련되어 설정될 수 있다면, MSM 구현은 상기 'HScreen' 인스턴스 모두에 대해 'MultiScreenConfigurableContext' 인터페이스를 지원하여야 한다.
MSM 구현은, 'MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 기능성과 관련되어 설정될 수 없는 'HScreen' 인스턴스에 대해서도 'MultiScreenConfigurableContext' 인터페이스(1210)를 지원할 수 있다.
'MultiScreenConfigurableContext' 인터페이스(1210)의 주어진 구현은 모든 정의된 설정 변경을 지원할 필요는 없지만, 하드웨어 또는 다른 제한 때문에 특정 설정 변경만을 지원할 수는 있다. 'MultiScreenConfigurableContext' 인터페이스(1210)의 구현이 특정 설정 변경을 지원하지 않는다면, 상기 변경을 수행하기 위한 시도는, 이하 정의된 각각의 메소드 하에 정의된 바와 같이, 'IllegalStateException'가 발생하도록 하여야 한다.
'MultiScreenConfigurableContext' 인터페이스(1210)는 MSM I01 버전부터 적용된다.
도 13b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfigurableContext' 인터페이스의 필드를 도시한다.
'MultiScreenConfigurableContext' 인터페이스의 필드(1300)는 'static int CONFIGURABLE_SCREEN_PARAMETER_AUDIO_FOCUS(1302)', 'static int CONFIGURABLE_SCREEN_PARAMETER_AUDIO_SOURCE(1304)', 'static int CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER(1306)', 'static int CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA(1308)', 'static int CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_SCREEN(1310)', 'static int CONFIGURABLE_SCREEN_PARAMETER_OUTPUT_PORT(1312)', 'static int CONFIGURABLE_SCREEN_PARAMETER_SERVICE_CONTEXT(1314)', 'static int CONFIGURABLE_SCREEN_PARAMETER_VISIBILITY(1316)', 및 'static int CONFIGURABLE_SCREEN_PARAMETER_Z_ORDER(1318)' 중 적어도 하나를 포함한다.
'org.ocap.ui.MultiScreenContext' 인터페이스(1230)로부터 상속되는 필드(1320)는 'SCREEN_TYPE_DISPLAY', 'SCREEN_TYPE_LOGICAL' 중 적어도 하나를 포함한다.
'CONFIGURABLE_SCREEN_PARAMETER_AUDIO_SOURCE' 필드(1304)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_AUDIO_SOURCE'로 선언되며, 오디오 소스의 설정 가능성을 식별하는 설정 가능한 파라미터이다.
스크린의 오디오 소스(들)의 설정은 'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 'addAudioSources(..)' 메소드 및 'removeAudioSources(..)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조된 HScreen 인스턴스가 상기 오디오 소스(들)의 설정을 지원한다면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_AUDIO_SOURCE)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_AUDIO_SOURCE)' 메소드가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_AUDIO_SOURCE)' 메소 드는 'HScreenDevice[]' 타입의 값을 반환하여야 하며, 여기서 값 어레이(value array)의 각각의 엔트리는 해당 스크린의 오디오 소스 역할을 할 수 있는 해당 스크린의 억세스 가능한 스크린 디바이스이다.
'CONFIGURABLE_SCREEN_PARAMETER_AUDIO_SOURCE' 필드(1304)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_AUDIO_FOCUS' 필드(1302)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_AUDIO_FOCUS'로 선언되며, 오디오 포커스의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
스크린의 오디오 포커스의 설정은 'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 'assignAudioFocus(..)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조되는 'HScreen' 인스턴스가 오디오 소스(들)의 설정을 지원한다면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_AUDIO_FOCUS)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_AUDIO_FOCUS)' 메소드가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_AUDIO_FOCUS)' 메소드는 'HScreen[]' 타입의 값을 반환하여야 하며, 여기서 값 어레이(value array)의 각각의 엔트리는 오디오 포커스 스크린 역할을 할 수 있는 해당 스크린의 억세스 가능한 스크린 디바이스이다.
해당 스크린이 디스플레이 스크린이라면, 반환된 엔트리는, 오디오 포커스로 지정될 수 있는 해당 디스플레이 스크린에 현재 맵핑된 로지컬 스크린들에 제한되어야 한다. 디스플레이 스크린은 (디스플레이 스크린에 맵핑된 일부 로지컬 스크린에 오디오 포커스를 지정하는 것과 상반되게) 항상 오디오 포커스에 직접적으로 지정될 수 있으므로, 디스플레이 스크린은 상기 반환된 엔트리에 스스로 포함되지는 않는다.
스크린이 로지컬 스크린이며 로지컬 스크린이 디스플레이 스크린에 맵핑되어 있으며 오디오 포커스가 지정될 수 있다면, 상기 반환된 어레이는 상기 로지컬 스크린만을 포함하고 있어야 한다. 아니라면, 반환된 엔트리는 비어야 한다.
'CONFIGURABLE_SCREEN_PARAMETER_AUDIO_FOCUS' 필드(1302)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER' 필드(1306)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER'로 선언되며, 스크린 디바이스 z-order의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
스크린의 디바이스 'z-order'의 설정은 'org.ocap.ui.MultiScreenContext' 인터페이스(1230)에 의해 정의된 'setZOrder(HScreenDevice[])' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조되는 'HScreen' 인스턴스가 그 스크린 디바이스(들)의 'z-order'의 설정을 지원 한다면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER)'가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER)'는 'HScreenDevice[][]' 타입의 값을 반환하여야 하며, 여기서 상기 값 어레이의 각각의 엔트리는 그 순서가 상기 스크린 디바이스의 지원된 'z-order' 순서와 일치하는 스크린 디바이스들의 어레이이며, 여기서 스크린 디바이스들의 상기 어레이의 첫 번째 엔트리는 z-order 상 가장 마지막 디바이스, 즉 디바이스 'z-order'가 0이다.
도 13c 는 'CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER' 필드의 사용례를 도시한다.
도 13c 에서는 (1) 스크린이 하나의 백그라운드 디바이스(B1), 하나의 비디오 디바이스(V1), 두 개의 그래픽 디바이스(G1 및 G2)를 구비하며, (2) 그래픽 디바이스의 두 가지 순서, 즉 (ⅰ) B1<V1<G1<G2 및 (ⅱ) B1<V1<G2<G1가 지원되는 경우가 상정된다.
S 1330를 통해 백그라운드 디바이스 B1의 'z-order'는 '0'이고, 비디오 디바이스 V1의 'z-order'는 '1'이며, 그래픽 디바이스 G1의 'z-order'는 '2', 그래픽 디바이스 G2의 'z-order'는 '3'임이 확인된다.
마찬가지로 S 1340를 통해 백그라운드 디바이스 B1의 'z-order'는 '0'이고, 비디오 디바이스 V1의 'z-order'는 '1'이며, 그래픽 디바이스 G2의 'z-order'는 '2', 그래픽 디바이스 G1의 'z-order'는 '3'임이 확인된다.
'CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER' 필드(1306)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA' 필드(1308)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA'로 선언되며, 스크린의 연관된 디스플레이 영역의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
(로지컬) 스크린의 디스플레이 영역의 설정은 'org.ocap.ui.MultiScreenContext' 인터페이스(1230)에 의해 정의된 'setDisplayArea(HScreenRectangle)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조된 'HScreen' 인스턴스가 디스플레이 스크린이면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA)' 메소드는 '거짓' 값을 반환하여야 한다. 로지컬 스크린이 상기 디스플레이 영역의 설정을 지원하면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA)' 메소드가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA)' 메소 드는 'HScreenRectangle[]' 타입의 값을 반환하여야 하며, 여기서 상기 값 어레이의 각각의 엔트리는 지원되는 디스플레이 영역이다.
'CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_AREA' 필드(1308)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_SCREEN' 필드(1310)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_SCREEN'로 선언되며, 스크린의 연관된 디스플레이 스크린의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
(로지컬) 스크린의 디스플레이 스크린의 설정은 'org.ocap.ui.MultiScreenContext' 인터페이스(1230)에 의해 정의된 'setDisplayScreen(HScreen)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조된 'HScreen' 인스턴스가 디스플레이 스크린이면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_SCREEN)' 메소드는 '거짓' 값을 반환하여야 한다. 그렇지 않으면, 로지컬 스크린이 상기 디스플레이 스크린의 설정을 지원하면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_ SCREEN)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_ SCREEN)' 메소드가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_ SCREEN)' 메 소드는 'HScreen []' 타입의 값을 반환하여야 하며, 여기서 상기 값 어레이의 각각의 엔트리는 로지컬 스크린이 맵핑될 수 있는 억세스 가능한 디스플레이 스크린이다.
'CONFIGURABLE_SCREEN_PARAMETER_DISPLAY_SCREEN' 필드(1310)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_OUTPUT_PORT' 필드(1312)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_OUTPUT_PORT'로 선언되며, 스크린의 연관된 출력 포트(들)의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
스크린의 출력 포트(들)의 설정은 'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 'addOutputPorts(..)' 메소드 및 'removeOutputPorts(..)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조된 'HScreen' 인스턴스가 그 비디오 출력 포트(들)의 설정을 지원한다면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_Ouput_Port)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_OUTPUT_ PORT)' 메소드가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_OUTPUT_PORT)' 메소드는 'VideoOutputPort[]' 타입의 값을 반환하여야 하며, 여기서 상기 값 어레이의 각각의 엔트리는 상기 스크린이 직접적으로 맵핑될 수 있는 억세스 가능한 비디오 출력 포트이다.
'CONFIGURABLE_SCREEN_PARAMETER_OUTPUT_PORT' 필드(1312)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_SERVICE_CONTEXT' 필드(1314)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_SERVICE_CONTEXT'로 선언되며, 스크린의 연관된 서비스 컨텍스트(들)의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
스크린의 서비스 컨텍스트(들)의 설정은 'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 'addServieContexts(..)' 메소드 및 'removeServieContexts(..)' 메소드를 사용하고, 'MultiScreenManager'에 의해 정의된 'swapServiceContexts(..)' 메소드 및 'moveServiceContexts(..)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조된 'HScreen' 인스턴스가 그 출력 포트(들)의 설정을 지원한다면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_SERVICE_CONTEXT)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_ SERVICE_CONTEXT)' 메소드가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_ SERVICE_CONTEXT)' 메소드는 'ServiceContext[]' 타입의 값을 반환하여야 하며, 여기서 상기 값 어레 이의 각각의 엔트리는 상기 스크린과 연관될 수 있는 억세스 가능한 서비스 컨텍스트이다.
'CONFIGURABLE_SCREEN_PARAMETER_SERVICE_CONTEXT' 필드(1314)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_VISIBILITY' 필드(1316)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_VISIBILITY'로 선언되며, 스크린의 가시성의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
스크린의 가시성의 설정은 'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 'setVisible(boolean)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조된 'HScreen' 인스턴스가 그 가시성의 설정을 지원한다면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_VISIBILITY)' 메소드는 '참' 값을 반환하여야 하지만, 'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_VISIBILITY)' 메소드는 '거짓' 값을 반환하여, 가시성이 설정 가능하다면 연속적인 파라미터의 영역(즉, '참' 값 및 '거짓' 값 모두)이 적용됨을 포함하여야 한다.
'CONFIGURABLE_SCREEN_PARAMETER_VISIBILITY' 필드(1316)는 MSM I01 버전으로부터 적용된다.
'CONFIGURABLE_SCREEN_PARAMETER_Z_ORDER' 필드(1318)는 'static final int CONFIGURABLE_SCREEN_PARAMETER_Z_ORDER'로 선언되며, 스크린의 'z-order'의 설정 가능성을 나타내는 설정 가능한 파라미터이다.
스크린의 'z-order'의 설정은 'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 'setZOrder(int)' 메소드를 사용함으로써 수행된다.
'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 참조된 'HScreen' 인스턴스가 (멀티스크린 설정 내의 다른 스크린들과의) 'z-order'의 설정을 지원한다면, 'isConfigurableParameter(CONFIGURABLE_SCREEN_PARAMETER_Z_ORDER)' 메소드는 '참' 값을 반환하여야 한다.
'hasDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_ Z_ORDER)' 메소드가 '참' 값을 반환한다면, 'getDiscreteParameterSpace(CONFIGURABLE_SCREEN_PARAMETER_ Z_ORDER)' 메소드는 'Integer[]' 타입의 값을 반환하여야 하며, 여기서 상기 값 어레이의 각각의 엔트리, 'v' ,는 'v.intValue()'이 상기 스크린의 멀티스크린 설정의 컨텍스트 상의 상기 스크린을 위해 지원된 'z-order' 인덱스를 반환하게 하는 값이다.
'CONFIGURABLE_SCREEN_PARAMETER_Z_ORDER' 필드(1318)는 MSM I01 버전으로부터 적용된다.
'org.ocap.ui.MultiScreenContext'로부터 상속된 필드(Fields inherited from interface org.ocap.ui.MultiScreenContext)(1320)는 'SCREEN_TYPE_DISPLAY', 'SCREEN_TYPE_LOGICAL'를 포함한다.
도 13d 내지 13f 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfigurableContext' 인터페이스의 메소드를 도시한다.
'org.ocap.ui.MultiScreenContext' 인터페이스의 메소드(1350)는, 'void addAudioSources(org.havi.ui.HScreenDevice[] devices, boolean mixWithAudioFocus)'(1352), 'void addOutputPorts(org.ocap.hardware.VideoOutputPort[] ports, boolean removeExisting)'(1354), 'void addServiceContexts(javax.tv.service.selection.ServiceContext[] contexts, boolean associateDefaultDevices)'(1356), 'void assignAudioFocus()'(1358), 'Boolean checkServiceContextCompatibility(javax.tv.service.selection.ServiceContext context)'(1360), 'org.davic.resources.ResourceClient getClient()'(1362), 'java.lang.Object[] getDiscreteParameterSpace(int parameter)'(1364), 'boolean hasDiscreteParameterSpace(int parameter)'(1366), 'boolean isConfigurableParameter(int parameter)'(1368), 'void releaseScreen()'(1370), 'void removeAudioSources(org.havi.ui.HScreenDevice[] devices)'(1372), 'void removeOutputPorts(org.ocap.hardware.VideoOutputPort[] ports)'(1374), 'void removeServiceContexts(javax.tv.service.selection.ServiceContext[] contexts)'(1376), 'void requestMultiScreenConfigurationChange(MultiScreenConfiguration configuration,java.util.Dictionary serviceContextAssociations)'(1378), 'boolean reserveScreen(org.davic.resources.ResourceClient client, java.lang.Object requestData)'(1380), 'void setDisplayArea(org.havi.ui.HScreenRectangle rect)'(1382), 'void setDisplayScreen(org.havi.ui.HScreen screen)'(1384), 'void setMultiScreenConfiguration(MultiScreenConfiguration configuration, java.util.Dictionary serviceContextAssociations)'(1386), 'void setVisible(boolean visible)'(1388), 'void setZOrder(org.havi.ui.HScreenDevice[] devices)'(1390), 및 'void setZOrder(int order)'(1392) 중 적어도 하나를 포함한다.
'org.ocap.ui.MultiScreenContext' 인터페이스(1230)로부터 상속되는 메소드(1394)는, 'addMultiScreenConfigurationListener', 'addScreenContextListener', 'getAudioFocus', 'getAudioSources', 'getDisplayArea', 'getDisplayScreen', 'getID', 'getMultiScreenConfiguration', 'getMultiScreenConfigurations', 'getMultiScreenConfigurations', 'getOutputPorts', 'getScreenCategory', 'getScreenType', 'getServiceContexts', 'getVisible', 'getZOrder', 'getZOrder', 'removeMultiScreenConfigurationListener', 'removeScreenContextListener' 중 적어도 하나를 포함한다.
'isConfigurableParameter' 메소드(1368)는 'boolean isConfigurableParameter(int parameter)'로 선언되며, 설정가능한 파라미터가 일부 스크린을 위한 플랫폼 구현에 의해 설정 가능하도록 (즉, 고정되는 것과 상반되는 의미로) 지원되는지 여부를 결정한다.
'parameter' 파라미터는 전술된 바와 같이 정의된 설정 가능한 스크린 파라미터 목록이다. 'isConfigurableParameter' 메소드(1368)는, 상기 플랫폼 구현이 상기 스크린에 대한 소정 'parameter'의 연속적인 변화 및 불연속적인 변화 중 어느 하나를 지원한다면, '참' 값을 반환하며, 다른 경우에는 '거짓' 값을 반환한다.
'isConfigurableParameter' 메소드(1368)는 MSM I01 버전으로부터 적용된다.
'hasDiscreteParameterSpace' 메소드(1366)는 'boolean hasDiscreteParameterSpace(int parameter)'로 선언되며, 지원된 설정가능한 파라미터가 불연속적으로 변하거나 연속적으로 변하는 값의 공간을 갖는지 여부를 결정한다.
여기서, '연속적으로' 변하는 파라미터는 플랫폼이 상기 파라미터의 값 타입의 모든 값들을 지원하거나 근사치를 가질 수 있음을 의미하며, 반면에 '불연속'은, 상기 파라미터의 값 타입의 소정의 셀 수 있는 값들만이 'getDiscreteParameterSpace(..)'에 의해 반환된 대로 사용될 수 있음을 의미한다.
'parameter' 파라미터는 전술된 대로 정의된 설정 가능한 스크린 파라미터들의 값이다. 플랫폼 구현이 상기 스크린에 대한 소정 'parameter'의 값 타입 공간의 불연속적인 값들을 지원하는 경우, 'hasDiscreteParameterSpace' 메소드(1366)는 ' 참' 값을 반환한다. 그렇지 않으면, 상기 값 타입의 공간의 모든 값들이 지원되거나 근사치가 구해지는 경우, 'hasDiscreteParameterSpace' 메소드(1366)는 '거짓' 값을 반환한다.
'isConfigurableParameter(parameter)'(1368)가 '거짓' 값을 반환한다면 'hasDiscreteParameterSpace' 메소드(1366)는 'java.lang.IllegalArgumentException'를 발생시킨다.
'hasDiscreteParameterSpace' 메소드(1366)는 MSM I01 버전으로부터 적용된다.
'getDiscreteParameterSpace' 메소드(1364)는 'java.lang.Object[] getDiscreteParameterSpace(int parameter)'로 선언되며, 설정가능한 파라미터의 값 타입 공간의 불연속적인 값들의 (서브)셋을 획득한다.
'getDiscreteParameterSpace' 메소드(1364)에 의해 반환된 어레이의 실제 런타임 타입 및 어레이의 인자들은, 전술된 각각의 설정 파라미터의 설명에 의해 상세히 기술된 대로 소정의 설정가능한 파라미터를 위해 정의되어야 한다.
소정의 설정가능한 파라미터의 정의에 의해 다르게 정해지지 않는다면, 'getDiscreteParameterSpace' 메소드(1364)에 의해 반환된 어레이의 엔트리의 순서는 본 명세서에 의해 정의되지 않으며, 호환 가능한 어플리케이션에 의존적인 구현되는 것으로 간주되어야 한다.
지원된 불연속적 파라미터들은, 스크린의 기저 리소스의 동적 상태에 기초하는 스크린의 라이프타임(lifetime) 동안, 주어진 스크린 및 주어진 설정가능한 파 라미터를 위해 변한다. 그러나, 불연속적 파라미터의 변화가 있다면, 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 전송이 완료되는 시점과 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트 전송이 완료되는 시점 사이의 기간 외에는 변화가 발생하면 안 된다.
'parameter' 파라미터는 전술된 대로 정의된 설정가능한 스크린 파라미터 목록 값이다. 'getDiscreteParameterSpace' 메소드(1364)는 객체 인스턴스들의 어레이를 반환하며, 상기 객체 인스턴스 각각은 상기 플랫폼을 지원하는(또는 근사치를 구할 수 있는) 지정된 파라미터의 불연속적인 값이다.
'isConfigurableParameter(parameter)' 메소드(1368) 또는 'hasDiscreteParameterSpace(parameter)' 메소드(1366)가 '거짓' 값을 반환하면, 'getDiscreteParameterSpace' 메소드(1364)는 'java.lang.IllegalArgumentException'를 발생시켜야 한다.
'getDiscreteParameterSpace' 메소드(1364)는 MSM I01 버전으로부터 적용된다.
'setVisible' 메소드(1388)는 'void setVisible(boolean visible)'로 선언되며, 스크린 가시성을 설정한다.
해당 스크린이 로지컬 스크린이라면, 해당 스크린이 (이전에 가시성이 없던 스크린이라면) 가시성이 있도록 표시되거나, (이전에 가시성이 있었다면) 가시성이 없도록 표시되게 한다. 해당 스크린이 디스플레이 스크린이라면, 상기 디스플레이 스크린에 맵핑되는 모든 로지컬 스크린들이 (이전에 가시성이 없었다면) 가시성이 있도록 표시되거나, (이전에 가시성이 있었다면) 가시성이 없도록 표시되게 한다.
'visible' 파라미터는 해당 로지컬 'HScreen' 또는 해당 디스플레이 스크린에 맵핑되는 로지컬 스크린들이 그와 연관된 디스플레이 'HScreen' 상에 가시성이 있게 되거나 가시성이 없게 되는지 여부를 나타내는 불리언(boolean) 값이다.
호출 스레드(calling thread)에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않았다면, 'setVisible' 메소드(1388)는 'java.lang.SecurityException'를 발생시킨다.
해당 'HScreen'의 가시성이 변경될 수 없다면, 예를 들어 해당 플랫폼이 불변의 가시성 설정을 사용하고 있다면, 'setVisible' 메소드(1388)는 'java.lang.IllegalStateException'를 발생시킨다.
'setVisible' 메소드(1388)는 MSM I01 버전으로부터 적용된다.
'setZOrder(int)' 메소드(1392)가 'void setZOrder(int order)'로 선언되는 경우, 'setZOrder(int)' 메소드(1392)는 스크린 'z-order'를 설정한다.
'setZOrder(int)' 메소드(1392)는, 로지컬 'HScreen'이 동일한 디스플레이 'HScreen'에 맵핑된 다른 로지컬 'HScreen'들 사이의 'z-order'를 변경하게 한다.
'order' 파라미터는 해당 로지컬 'HScreen'에 지정할 새로운 'z-order'를 나타내는 양의 정수 값이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않았다면, 'setZOrder(int)' 메소드(1392)는 'java.lang.SecurityException' 를 발생시킨다. 해당 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이 아니거나, 해당 'HScreen'의 'z-order'가 변경될 수 없다면, 예를 들면 해당 플랫폼이 영구적인 'z-order' 설정을 사용한다면, 'setZOrder(int)' 메소드(1392)는 'java.lang.IllegalStateException'를 발생시킨다.
'setZOrder(int)' 메소드(1392)는 MSM I01 버전으로부터 적용된다.
'setZOrder(HScreenDevice[])' 메소드(1390)는 'void setZOrder(org.havi.ui.HScreenDevice[] devices)'로 선언되며, 스크린 디바이스들을 위해 해당 스크린 내의 스크린 디바이스의 'z-order'를 설정한다.
'setZOrder(HScreenDevice[])' 메소드(1390)는 이하의 제한 조건을 만족하는 스크린 내의 소정 'HScreenDevice'들의 'z-order'를 세부적으로 설정한다.
- 'HBackgroundDevice'가 지정된 디바이스들에 존재한다면, (ⅰ) 'HBackgroundDevice'는 디바이스들에 포함된 모든 'HVideoDevice'보다 앞서고, (ⅱ) 디바이스들에 포함된 모든 'HGraphicsDevice'보다 앞선다.
- 'HVideoDevice'가 소정 디바이스들에 존재한다면, 'HVideoDevice'는 디바이스들에 포함된 모든 'HGraphicsDevice'보다 앞선다.
'setZOrder(HScreenDevice[])' 메소드(1390)에 의해 예외가 발생되지 않는다면, 지정된 'HScreenDevice' 인스턴스들은 순서가 정해져서, 지정된 디바이스들 중 적어도 하나에 대한 해당 스크린에 대해 'MultiScreenContext.getZOrder(HScreenDevice)' 메소드가 호출된 때, 'MultiScreenContext.getZOrder(HScreenDevice)' 메소드는 지정된 디바이스들의 상 대적인 순서를 저장하는 'z-order'를 반환하게 된다.
해당 스크린과 연관된 'HScreenDevice' 인스턴스들 전체보다 적은 디바이스 인스턴스가 'devices' 인자 내에 제공된다면, 'MultiScreenContext.getZOrder(HScreenDevice)' 메소드에 의해 정의된 제한 조건이 'setZOrder(HScreenDevice[])' 메소드(1390)의 반환 후 해당 스크린 상의 디바이스들의 모든 순서에 적용되어야 한다는 조건을 제외하고, 지정된 디바이스들에 관련해 지정되지 않은 디바이스들의 상대적 순서가 결과로써 정의되지 않는다.
'devices' 파라미터는 해당 스크린과 연관된 'HScreenDevice' 인스턴스들의 정렬된 어레이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않았다면, 'setZOrder(HScreenDevice[])' 메소드(1390)는 'java.lang.SecurityException'는 발생시킨다.
'device'가 해당 스크린의 'HScreenDevice'가 아니라면, 'setZOrder(HScreenDevice[])' 메소드(1390)는 'java.lang.IllegalArgumentException'를 발생시킨다.
(ⅰ) 소정 'HScreenDevice'의 'z-order'가 변경될 수 없다면, 예를 들어 플랫폼이 해당 스크린의 스크린 디바이스들의 영구적인 'z-order' 설정을 사용한다면, 또는 (ⅱ) 소정 디바이스들의 순서에 상기 제한 조건을 만족하는 'z-order' 인덱스들의 지정이 허용되지 않는다면, 'setZOrder(HScreenDevice[])' 메소드(1390)는 'java.lang.IllegalStateException'를 발생시켜야 한다.
'setZOrder(HScreenDevice[])' 메소드(1390)는 MSM I01 버전으로부터 적용된다.
'addAudioSources' 메소드(1352)는 'void addAudioSources(org.havi.ui.HScreenDevice[] devices, boolean mixWithAudioFocus)'로 선언되며, 해당 스크린을 위한 오디오 소스(들)을 부가한다. 'addAudioSources' 메소드(1352)는, 그 재생되는 오디오가 해당 스크린으로부터 오디오 재생을 하기 위해 선택( 및 믹싱)되는 오디오 소스들에 하나 이상의 'HScreenDevice' 인스턴스를 부가한다.
소정 오디오 소스가 해당 스크린을 위한 오디오 소스로 이미 지명되었지만, 'mixWithAudioFocus' 가 오디오 소스로써 부가된 경우 지정된 오디오 소스와 다르다면, 새로운 'mixWithAudioFocus' 값이 적용된다.
'devices' 파라미터는 'HScreenDevice' 인스턴스의 비지 않은 어레이이며, 여기서 각각의 'HScreenDevice' 인스턴스는 해당 스크린으로부터 믹싱된 오디오 재생에 관여한다.
'mixWithAudioFocus' 파라미터가 '참' 값이라면, 지정된 스크린 디바이스들은, 해당 스크린이 오디오 포커스에 지정되었는지 여부와 관계 없이 해당 스크린이 직간접적으로 연관된 비디오 출력 포트와에 연관된 오디오 출력에 오디오를 관여(또는 오디오와 믹스)시킨다. 'mixWithAudioFocus' 파라미터가 'false' 값이라면, 상기 지정된 스크린 디바이스들은 해당 스크린이 오디오 포커스에 지정될 때에만 오디오를 관여시킨다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않은 경우, 'addAudioSources' 메소드(1352)는 'java.lang.SecurityException'를 발생시킨다.
'devices'가 비지 않은 어레이가 아니거나, 'devices'의 일부 엔트리가 해당 스크린의 'HScreenDevice'가 아니라면, 'addAudioSources' 메소드(1352)는 'java.lang.IllegalArgumentException'를 발생시킨다.
(ⅰ) 소정 'HScreenDevice'의 오디오 소스들이 변경될 수 없다면, 예를 들어 플랫폼이 해당 스크린의 스크린 디바이스들의 영구적인 오디오 소스 설정을 사용한다면, 또는 (ⅱ) 복수 개의 오디오 소스들이 특정되고 오디오 믹싱이 지원되지 않는다면, 'addAudioSources' 메소드(1352)는 'java.lang.IllegalStateException'를 발생시켜야 한다.
'addAudioSources' 메소드(1352)는 MSM I01 버전으로부터 적용된다.
'removeAudioSources' 메소드(1372)는 'void removeAudioSources(org.havi.ui.HScreenDevice[] devices)'로 선언되며, 해당 스크린으로부터 오디오 소스(들)을 제거한다. 'removeAudioSources' 메소드(1372)는 해당 'HScreen'의 오디오 소스들로부터의 소정 'HScreenDevice' 인스턴스의 모든 또는 일부 비지 않은 스크린 디바이스들을 제거한다. 만약 'devices'가 'null' 값이라면, 모든 오디오 소스들은 제거된다.
'devices' 파라미터는 'null' 값이거나 비지 않은 'HScreenDevice' 인스턴스들을 나타낸다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않은 경우, 'removeAudioSources' 메소드(1372)는 'java.lang.SecurityException'를 발생시킨다.
'devices'가 비지 않은 어레이가 아니고, 일부 'HScreenDevice' 엔트리가 'HScreen' 인스턴스에 연관되지 않는다면, 'removeAudioSources' 메소드(1372)는 'java.lang.IllegalArgumentException'를 발생시킨다.
소정 해당 'HScreen'을 위한 오디오 소스로 사용되는 소정 'HScreenDevice'가 변경될 수 없다면, 예를 들어 플랫폼이 소정 'HScreenDevice'와의 오디오 소스들의 영구적인 연관 관계를 사용한다면, 'removeAudioSources' 메소드(1372)는 'java.lang.IllegalStateException'를 발생시켜야 한다.
'removeAudioSources' 메소드(1372)는 MSM I01 버전으로부터 적용된다.
'assignAudioFocus' 메소드(1358)는 'void assignAudioFocus()'로 선언되며, 해당 스크린의 오디오 포커스를 지정한다.
소정 시간에, 디스플레이 스크린은 스스로에게 오디오 포커스를 지정하거나, 상기 디스플레이 스크린에 맵핑되는 단 하나의 로지컬 스크린에 오디오 포커스를 지정하여야 한다. 오디오 포커스가 디스플레이 스크린의 로지컬 스크린에 새로 지정되고 상기 로지컬 스크린이 상기 로지컬 스크린에 현재 지정된 오디오 포커스를 구비하고 있지 않을 때, 오디오 포커스는 해당 디스플레이 스크린에 맵핑된 다른 로지컬 스크린으로부터 제거되고, 새로 지정된 로지컬 스크린에 대신 지정된다.
로지컬 스크린이 주어진 디스플레이 스크린에 맵핑되지 않거나, 주어진 디스 플레이 스크린에 맵핑된 로지컬 스크린에 오디오 포커스가 지정되지 않았다면, 디스플레이 스크린은 스스로에게 오디오 포커스를 (디폴트로) 지정하여야 한다. 디스플레이 스크린 인스턴스에 대해 'assignAudioFocus' 메소드(1358)를 사용함으로써 오디오 포커스가 디스플레이 스크린에 명시적으로 지정될 수 있다.
디스플레이 스크린의 오디오 포커스 스크린은, 그의 현재 선택된 오디오 소스들이 디스플레이 스크린이 맵핑된 모든 비디오 출력 포트들의 모든 (잠재된) 오디오 재생 디바이스들에서 재생되기 위해 지정된 스크린이다. 오디오 포커스가 지정된 스크린이 오디오 소스를 가지지 않는다면, 즉 빈 오디오 소스들을 가진다면, (OCAP 플랫폼에 의해 되거나 재생되거나 재생될 가능성이 있는) 오디오는 해당 디스플레이 스크린이 맵핑된 모든 비디오 출력 포트들의 어떤 (내재된) 오디오 재생 디바이스에 의해서도 재생되어서는 안 된다.
각각의 별개 디스플레이 스크린은 디스플레이 스크린의 오디오를 재생할 목적으로 오디오 포커스가 지정된 별개의 로지컬 스크린( 및 맵핑된 로지컬 스크린들의 집합)을 가질 수 있다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않았다면, 'assignAudioFocus' 메소드(1358)는 'java.lang.SecurityException'를 발생시킨다.
오디오 포커스가 해당 'HScreen'에 지정되지 않거나 현재 오디오 포커스가 변경될 수 없다면, 'assignAudioFocus' 메소드(1358)는 'java.lang.IllegalStateException'를 발생시킨다.
'assignAudioFocus' 메소드(1358)는 MSM I01 버전으로부터 적용된다.
'addOutputPorts' 메소드(1354)는 'void addOutputPorts(org.ocap.hardware.VideoOutputPort[] ports, boolean removeExisting)'로 선언되며, 스크린이 맵핑된 비디오 출력 포트(들)을 부가한다.
'HScreen'이 디스플레이 스크린이 아닌 로지컬 스크린이라면, 'HScreen'은 지정된 비디오 출력 포트(들)로 맵핑하기 위한 디스플레이 스크린과 동일한 기능을 수행하여야 한다. 즉, 로지컬 스크린이 스스로 메인 디스플레이 스크린인 것처럼 다루어져야 한다.
'ports' 파라미터는 'VideoOutputPort' 인스턴스의 비지 않은 어레이이다. 'removeExisting' 파라미터가 '참' 값이라면, 새로운 스크린에 부가되기 전에 현재 스크린과의 연관 관계는 (이런 연관 관계가 있다면) 제거되어야 한다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않는다면, 'addOutputPorts' 메소드(1354)는 'java.lang.SecurityException'를 발생시킨다.
(ⅰ) 지정된 'VideoOutputPort'가 이미 다른 'HScreen'과 연관되고 'removeExisting'이 '참' 값이 아니거나, (ⅱ) 일부 플랫폼 세부 하드웨어 제한 조건 때문에 해당 'HScreen'이 일부 지정된 'VideoOutputPort'에 맵핑될 수 없거나, (ⅲ) 해당 'HScreen'이 맵핑된 'VideoOutputPort' 인스턴스들이 변경될 수 없다면, 예를 들어 상기 플랫폼이 소정 'VideoOutputPort' 인스턴스들과의 영구적인 연관 관계를 사용한다면, 'addOutputPorts' 메소드(1354)는 'java.lang.IllegalStateException'를 발생시킨다.
'addOutputPorts' 메소드(1354)는 MSM I01 버전으로부터 적용된다.
'removeOutputPorts' 메소드(1374)는 'void removeOutputPorts(org.ocap.hardware.VideoOutputPort[] ports)'로 선언되며, 해당 스크린이 맵핑된 비디오 출력 포트(들)을 제거한다. 'removeOutputPorts' 메소드(1374)는 'HScreen'이 맵핑된 비디오 출력 포트들로부터 모든 또는 일부 비지 않은 소정 'VideoOutputPort' 인스턴스들을 제거한다. 'ports' 파라미터가 'null' 값이라면 모든 비디오 출력 포트들 연관 관계는 제거된다.
'ports' 파라미터는 'null' 값 이거나 'VideoOutputPort' 인스턴스의 비지 않은 어레이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않은 경우, 'removeOutputPorts' 메소드(1374)는 'java.lang.SecurityException'를 발생시킨다.
'ports'가 비지 않은 어레이가 아니고 일부 'VideoOutputPort' 엔트리가 'HScreen' 인스턴스에 연관되지 않는다면, 'removeOutputPorts' 메소드(1374)는 'java.lang.IllegalArgumentException'를 발생시킨다.
소정 해당 'HScreen'을 위한 소정 'VideoOutputPort'가 변경될 수 없다면, 예를 들어 플랫폼이 소정 'VideoOutputPort'와의 영구적인 연관 관계를 사용한다면, 'removeOutputPorts' 메소드(1374)는 'java.lang.IllegalStateException'를 발생시켜야 한다.
'removeOutputPorts' 메소드(1374)는 MSM I01 버전으로부터 적용된다.
'setDisplayScreen' 메소드(1384)는 'void setDisplayScreen(org.havi.ui.HScreen screen)'로 선언되며, 로지컬 스크린을 디스플레이 스크린과 연관한다. 즉, 'setDisplayScreen' 메소드(1384)는 로지컬 'HScreen'는 디스플레이 'HScreen'과 연관한다.
'screen' 파라미터는 디스플레이 'HScreen' 인스턴스 또는 'null' 값이다. 만약 'screen' 파라미터가 'null' 값이고, 'setDisplayScreen' 메소드(1384)가 예외 없이 실행된다면, 'screen' 파라미터가 반환되면 상기 로지컬 'HScreen'은 디스플레이 'HScreen'과 더 이상 연관되지 않는다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않는다면, 'setDisplayScreen' 메소드(1384)는 'java.lang.SecurityException'를 발생시킨다.
(ⅰ) 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이 아니거나, (ⅱ)지정된 'screen'이 'null' 값이 아니고 그 스크린 타입이 'SCREEN_TYPE_DISPLAY'가 아니거나, (ⅲ) 해당 로지컬 'HScreen'과 연관된 디스플레이 'HScreen'이 변경될 수 없다면, 예를 들어 상기 플랫폼이 소정 디스플레이 'HScreen'과의 영구적인 연관 관계를 사용한다면, 'setDisplayScreen' 메소드(1384)는 'java.lang.IllegalStateException'를 발생시킨다.
'setDisplayScreen' 메소드(1384)는 MSM I01 버전으로부터 적용된다.
'setDisplayArea' 메소드(1382)는 'void setDisplayArea(org.havi.ui.HScreenRectangle rect)'로 선언되며, 로지컬 스크린이 맵핑된 디스플레이 스크린의 영역을 설정한다. 즉, 로지컬 'HScreen'과 연관된 디스플레이 'HScreen'의 영역(범위)에 로지컬 'HScreen'을 연관한다.
'rect' 파라미터는 해당 로지컬 'HScreen'의 범위에 해당하여야 하는, 로지컬 'HScreen'과 연관된 디스플레이 'HScreen' 상의 영역을 나타내는 'HScreenRectangle' 인스턴스이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않는 다면, 'setDisplayArea' 메소드(1382)는 'java.lang.SecurityException'를 발생시킨다.
(ⅰ) 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이 아니거나, (ⅱ) 해당 로지컬 'HScreen'과 연관된 디스플레이 'HScreen'의 영역이 변경될 수 없다면, 예를 들어 상기 플랫폼이 소정 디스플레이 'HScreen'의 소정 영역과의 영구적인 연관 관계를 사용한다면, 'setDisplayArea' 메소드(1382)는 'java.lang.IllegalStateException'를 발생시킨다.
'setDisplayArea' 메소드(1382)는 MSM I01 버전으로부터 적용된다.
'checkServiceContextCompatibility' 메소드(1360)는 'boolean
checkServiceContextCompatibility(javax.tv.service.selection.ServiceContext context)'로 선언되며, 해당 스크린의 서비스 컨텍스트의 호환성을 시험한다. 즉, 'checkServiceContextCompatibility' 메소드(1360)는 어플리케이션이 해당 'HScreen'에 'ServiceContext'를 지정할 수 있는 여부 및 지정된 'ServiceContext' 가 상기 'HScreen'에서의 재생과 호환 가능한지 여부를 결정한다.
'context' 파라미터는 유효한 'ServiceContext' 인스턴스이다.
'checkServiceContextCompatibility' 메소드(1360)는, 지정된 'ServiceContext' 인스턴스가 상기 'HScreen'에 지정될 수 있는지 여부를 나타내는 불리언(Boolean) 값을 반환한다. 지정된 'ServiceContext' 인스턴스가 지정될 수 있다면 '참' 값이 반환되고, 지정될 수 없다면 '거짓' 값이 반환된다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않았다면, 'checkServiceContextCompatibility' 메소드(1360)는 'java.lang.SecurityException'를 발생시킨다.
지정된 'ServiceContext'가 유효하지 않다면, 'checkServiceContextCompatibility' 메소드(1360)는 'java.lang.IllegalArgumentException'가 발생시킨다.
'checkServiceContextCompatibility' 메소드(1360)는 MSM I01 버전으로부터 적용된다.
'addServiceContexts' 메소드(1356)는 'void addServiceContexts(javax.tv.service.selection.ServiceContext[] Contexts, boolean associateDefaultDevices)'로 선언되며, 해당 스크린에 서비스 컨텍스트를 부가한다. 즉, 'addServiceContexts' 메소드(1356)는, 상기 'ServiceContext' 인스턴스들로부터의 백그라운드, 비디오 및 그래픽 컨텐츠가 'HScreen'의 각각의 스크린 디바이스 중에서 재생되는 것을 허용하기 위하여 상기 'HScreen'과 연관된 서비 스 컨텍스트들에, 하나 이상의 'ServiceContext' 인스턴스들을 부가한다.
지정된 서비스 컨텍스트가 'org.ocap.ui.MultiScreenContext' 인터페이스에 의해 표현되는 기저 스크린과 이미 연관되었다면, 상기 서비스 컨텍스트는 상기 스크린과 복수로 연관되지 않으며, 현존하는 연관 관계가 손상되지 않은 채 남는다. 즉, 주어진 서비스 컨텍스트는 주어진(소정) 스크린과 한번 연관되거나, 전혀 연관되지 않는다.
둘 이상의 비추상 서비스 컨텍스트가 주어진 스크린과 연관되고, 상기 복수 개의 비추상 서비스 컨텍스트들의 백그라운드 기반 플레이어들로부터의 복수 개의 비디오 소스들이 주어진 스크린의 주어진 'HVideoDevice'와 연관된다면, 그 비디오 컨텐츠가 재생될 상기 복수 개의 비추상 서비스 컨텍스트들로부터의 백그라운드 기반 플레이어가 후술되는 규칙을 순서대로 준수함으로써 결정된다.
1. 상기 연관된 비추상 서비스 컨텍스트들 중 하나의 해당 어플리케이션이 해당 스크린의 주어진 'HVideoDevice'에 대한 예약 할당을 유지한다면, 서비스 컨텍스트로부터의 백그라운드 기반 플레이어 컨텐츠는 상기 비디오 디바이스 중에서 재생하도록 지명된다.
2. 주어진 'HVideoDevice'에 대한 예약 할당이 유지되지 않는다면, 가장 우선권이 지정된 어플리케이션의 상기 연관된 비추상 서비스 컨텍스트의 백그라운드 기반의 플레이어가 상기 비디오 디바이스 중에서 재생하도록 지명된다.
상기 규칙들이 적용된 후, 주어진 어플리케이션의 복수 개의 백그라운드 기반의 플레이어들이 비디오 디바이스 중에서 재생하도록 지명된다면, 가장 최근에 시작됐던 플레이어에 비디오 재생을 위한 우선권이 주어진다.
'contexts' 파라미터는 'ServiceContext' 인스턴스들의 비지 않은 어레이다. 'associateDefaultDevices' 파라미터가 'true'라면, 해당 스크린의 연관된 디폴트 스크린 디바이스들은, 지정된 'Servicecontext' 인스턴스들과 현재 연관된 모든 'ServiceMediaHandler' 인스턴스들과 연관된다. 'associateDefaultDevices' 파라미터가 'false'라면, 상기 디폴트 스크린 디바이스들과의 연관 관계가 허용되지 않는다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않았다면, 'addServiceContexts' 메소드(1356)는 'java.lang.SecurityException'를 발생시킨다.
상기 'HScreen'을 위한 일부 지정된 'ServiceContext'가 변경될 수 없다면, 예를 들어 상기 플랫폼이 소정 'ServiceContext'과의 영구적인 연관 관계를 사용한다면, 'addServiceContexts' 메소드(1356)는 'java.lang.IllegalStateException'가 발생시킨다.
'addServiceContexts' 메소드(1356)는 MSM I01 버전으로부터 적용된다.
'removeServiceContexts' 메소드(1376)는 'void removeServiceContexts(javax.tv.service.selection.ServiceContext[] contexts)'로 선언되며, 해당 스크린으로부터 서비스 컨텍스트(들)를 제거한다. 즉, 'removeServiceContexts' 메소드(1376)는 'HScreen'과 연관된 서비스 컨텍스트들로부터 모든 또는 일부 비지 않은 소정 'ServiceContext' 인스턴스들을 제거한다. 'contexts' 파라미터가 'null' 값이라면 모든 서비스 컨텍스트들은 제거된다.
'contexts' 파라미터는 'null' 값 이거나 'ServiceContext' 인스턴스의 비지 않은 어레이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않은 경우, 'removeServiceContexts' 메소드(1376)는 'java.lang.SecurityException'를 발생시킨다.
'contexts' 가 비지 않은 어레이가 아니고 일부 'ServiceContext' 엔트리가 'HScreen' 인스턴스에 연관되지 않는다면, 'removeServiceContexts' 메소드(1376)는 'java.lang.IllegalArgumentException'를 발생시킨다.
'ServiceContext'가 변경될 수 없다면, 예를 들어 플랫폼이 소정 'ServiceContext'와의 영구적인 연관 관계를 사용한다면, 'removeServiceContexts' 메소드(1376)는 'java.lang.IllegalStateException'를 발생시켜야 한다.
'removeServiceContexts' 메소드(1376)는 MSM I01 버전으로부터 적용된다.
'setMultiScreenConfiguration' 메소드(1386)는 'void setMultiScreenConfiguration(MultiScreenConfiguration configuration, java.util.Dictionary serviceContextAssociations)'로 선언되며, 해당 디스플레이 스크린에 대해 현재 활성 멀티스크린 설정을 설정한다. 즉, 주어진 시간에 해당 디스플레이 스크린에 연관될 수 있는 로지컬 스크린들의 서브셋들 중에서 하나가 선택된다.
지정된 'configuration'이 해당 디스플레이 스크린을 위한 현재 설정이라면, 'SecurityException' 가 적용되지 않은 경우 아무런 반응 없이 'setMultiScreenConfiguration' 메소드(1386)로부터 값이 반환된다.
지정된 'configuration'이 해당 디스플레이 스크린을 위한 현재 설정이 아니고, 'SecurityException', 'IllegalStateException', 및 'IllegalStateException'가 적용되지 않는다면, 본 명세서에서 정의되는 동기적 디스플레이 멀티스크린 설정 변화 처리 작업이 수행된다.
'serviceContextAssociations' 인자가 특정된다면, 즉 'null' 값이 아니라면, 호출 어플리케이션에게 억세스 가능한 'ServiceContext' 인스턴스는 어떤 스크린에도 연관되지 않거나, 지정된 (새로운) 멀티스크린 설정의 적용 가능한 스크린(들)과 연관되어야 한다. 일부 억세스 가능한 'ServiceContext'와 연관되지 않거나, 일부 억세스 가능한 'ServiceContext' 인스턴스가 지정된 연관 관계에 존재하지 않거나, 연관 관계는 존재하지만 새로운 멀티스크린 설정 내에 적용 가능한 스크린이 존재하지 않는다면, 'ServiceContext' 인스턴스는 지정된 멀티스크린 설정의 디폴트 서비스 컨텍스트 연관 스크린, 즉 'configuration.getDefaultServiceContextScreen()' 메소드에 의해 반환된 스크린,과 연관되어야 한다.
그 참조들이 지정된 'serviceContextAssociations' 딕셔너리(dictionary)에서 키(key)로 표시되는 억세스 가능한 'ServiceContext' 인스턴스들이 서로 일치되기 위해, 상기 키들에 대한 가상 메소드 'equals(Object)'가 사용되어야 하며, 이 경우 'setMultiScreenConfiguration' 메소드(1386)는 'Object.equals(Object)' 메 소드의 디폴트 구현과 동일하게 동작한다고 가정된다.
주어진 어플리케이션 인스턴스의 컨텍스트에 있어서, MSM 호스트 구현은 상기 어플리케이션에 접하는 ServiceContext 인스턴스들과 기저 서비스 컨텍스트 리소스들의 집합 사이의 일대일 관계를 유지하여야 한다. MSM 호스트 구현이 상기 일대일 관계를 유지하지 못하면, 'serviceContextAssociations' 딕셔너리를 참고할 때 MSM 구현은 기저 서비스 컨텍스트 리소스들의 별개의 두 집합이 동일한 서비스 컨텍스트라고 간주할 수 있으며, 예를 들어 다른 시간이라면 단일 'ServiceContext' 인스턴스가 리소스들의 별개의 기저 집합을 참조한다고 간주할 수 있다. 또는, MSM 구현은, 기저 서비스 컨텍스트 리소스들의 단일 집합이 별개의 두 서비스 컨텍스트라고 간주될 수 있으며, 예를 들어, 주어진 시간이라면 별개의 두 'ServiceContext' 인스턴스들이 리소스들의 동일한 기저 집합을 참조한다고 간주할 수 있다.
'setMultiScreenConfiguration' 메소드(1386)에 의해 스크린들 사이에 내재적으로 교체되거나 이동되는 서비스 컨텍스트와 연관된 비디오를 처리하기 위해 사용되고 있는 비디오 파이프라인의 디코더 포캣 변환(DFC) 설정부의 상태는 'setMultiScreenConfiguration' 메소드(1386)의 수행 여부에 의해 영향을 받으면 안 된다.
'configuration' 파라미터는 해당 디스플레이 스크린에 대한 현재 활성화된 디스플레이별 멀티스크린 설정이 될 'MultiScreenConfiguration' 인스턴스이다.
'serviceContextAssociations' 파라미터가 'null' 값이 아니라면, 'serviceContextAssociations' 파라미터는 'ServiceContext' 인스턴스인 키 및 'String' 인스턴스인 값을 갖는 'Dictionary' 인스턴스이다. 여기서 스트링 값은 다음과 같이 정의된다: (ⅰ) 스트링 값이 "-"이라면, (부합하는 서비스 컨텍스트가 설정 변화 후의 스크린과 연관되지 않는 경우) 스크린이 적용되지 않는다.(ⅱ) 그렇지 않으면, 스트링 값이 "*"이라면, 새로운 스크린 설정의 모든 스크린들이 적용된다. (ⅲ) 그렇지 않으면 스트링 값이 'MultiScreenContext.getID()' 메소드에 의해 반환된 스크린 식별자라면, 해당 스크린이 적용된다. (ⅳ) 그렇지 않으면 스트링 값이 'MultiScreenContext.getScreenCategory()' 메소드에 의해 반환된 스크린 카테고리라면, 그 카테고리의 새로운 설정 중 어느 스크린이라도 적용된다. (ⅴ) 그렇지 않으면 스트링 값이 스크린 식별자들의 세미콜론으로 구분된 목록이라면, 부합하는 식별자에 대한 새로운 설정의 각각의 스크린가 적용된다. (ⅵ) 그렇지 않으면 스티링 값이 스크린 카테고리들의 세미콜론으로 구분된 리스트라면, 부합하는 카테고리에 대한 새로운 설정의 각각의 스크린이 적용된다. (ⅶ) 그렇지 않으면, 스트링 값이 스크린 식별자들 또는 스크린 카테고리들의 세미콜론으로 구분된 리스트라면, 부합하는 식별자 또는 카테고리의 새로운 설정의 각각의 스크린이 적용된다. (ⅷ) 그렇지 않으면, 새로운 설정의 디폴트 서비스 컨텍스트 연관 스크린이 적용된다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'setMultiScreenConfiguration' 메소드(1386)는 'java.lang.SecurityException'를 발생시킨다.
'Configuration' 파라미터가 'MultiScreenContext.getMultiScreenConfigurations()' 메소드에 의해 반환될 해당 (디스플레이) 스크린의 멀티스크린 설정들 중 하나가 아니라면, 'setMultiScreenConfiguration' 메소드(1386)는 'java.lang.IllegalArgumentException'를 발생시킨다.
해당 스크린이 디스플레이 스크린이 아니거나 (ⅰ) MSM 구현이 지정된 멀티스크린 설정의 활성화를 허용하지 않거나, (ⅱ) 'setMultiScreenConfiguration' 메소드(1386)가 이전에 호출되고, 변경 처리 과정이 아직 완료되지 않거나, (ⅲ) 그렇지 않으면 메소드 호출 시점에 활성화가 허용되지 않았다면, 'setMultiScreenConfiguration' 메소드(1386)는 'java.lang.IllegalStateException'를 발생시킨다.
'setMultiScreenConfiguration' 메소드(1386)는 MSM I01 버전으로부터 적용된다.
'requestMultiScreenConfigurationChange' 메소드(1378)는 'void
requestMultiScreenConfigurationChange(MultiScreenConfiguration configuration, java.util.Dictionary serviceContextAssociations)'로 선언되며, 해당 디스플레이를 위한 현재 활성화된 멀티스크린 설정이 변경되기를 요청한다.
지정된 'configuration'이 해당 디스플레이 스크린을 이한 현재 설정이고, 'SecurityException'가 적용되지 않는다면, 아무런 부수 효과 없이 'requestMultiScreenConfigurationChange' 메소드(1378)로부터 값이 반환된다.
지정된 'configuration'가 현재 디스플레이 설정이 아니고, 'SecurityException', 'IllegalArgumentException', 및 'IllegalStateException'이 적용되지 않는다면, 현재 멀티스크린 설정에 대해 비동기적 변경이 초기화된다. 여기서 'MultiScreenConfiguration.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트가 생성된 후(아직 출력되기 이전에) 즉시 'requestMultiScreenConfigurationChange' 메소드(1378)가 값을 반환하는 경우를 제외하면, 'setMultiScreenConfiguration()' 메소드의 시맨틱이 적용된다.
'configuration' 파라미터는 현재 활성화된 스크린 설정이 될 'MultiScreenConfiguration' 인스턴스이다.
'serviceContextAssociations' 파라미터는, 앞서 'setMultiScreenConfiguration(..)'에 의해 정의된 시맨틱에 따라, 'null' 값이거나 그 키들이 'ServiceContext' 인스턴스들이고 그 값들이 'String' 인스턴스들인 'Dictionary' 타입이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'requestMultiScreenConfigurationChange' 메소드(1378)는 'java.lang.SecurityException'를 발생시킨다.
'configuration' 파라미터가 'MultiScreenContext.getMultiScreenConfigurations()' 메소드에 의해 반환되는 해당 (디스플레이) 스크린의 멀티스크린 설정들 중 하나가 아니라면, 'requestMultiScreenConfigurationChange' 메소드(1378)는 'java.lang.IllegalArgumentException'를 발생시킨다.
해당 스크린이 디스플레이 스크린이 아니거나 (ⅰ) MSM 구현이 지정된 멀티스크린 설정의 활성화를 허용하지 않거나, (ⅱ) 'setMultiScreenConfiguration' 메소드(1378)가 이전에 호출되고 변경 처리 과정이 아직 완료되지 않거나, (ⅲ) 그렇지 않으면 메소드 호출 시간에 활성화가 허용되지 않았다면, 'setMultiScreenConfiguration' 메소드(1378)는 'java.lang.IllegalStateException'를 발생시킨다.
'requestMultiScreenConfigurationChange' 메소드(1378)는 MSM I01 버전으로부터 적용된다.
'getClient' 메소드(1362)는 'org.davic.resources.ResourceClient getClient()'로 선언되며, 'HScreen' 인스턴스와 연관된 기저 스크린 및 상기 스크린 리소스들에 대한 예약 할당을 현재 유지하고 있는 리소스 클라이언트를 획득한다.
'getClient' 메소드(1362)는 인터페이스 'org.davic.resources.ResourceProxy'의 'getClient'에서도 상술된다.
'getClient' 메소드(1362)는, 'ResourceClient' 인스턴스를 반환하거나, 해당 'HScreen'과 연관된 기저 스크린 및 스크린 리소소들이 예약 할당되지 않는다면 'null' 값을 반환한다.
'getClient' 메소드(1362)는 MSM I01 버전으로부터 적용된다.
'reserveScreen' 메소드(1380)는 'boolean reserveScreen(org.davic.resources.ResourceClient client, java.lang.Object requestData)'로 선언되며, 해당 스크린의 기저 리소스들을 세부적으로 예약 할당한다.
'reserveScreen' 메소드(1380)를 사용하여 스크린이 예약 할당될 때, 모든 'HScreenDevice' 인스턴스들 및 해당 스크린의 모든 기저 스크린 리소스들을 먼저 해제하지 않으면 각각의 'HscreenDevice' 인스턴스들이 해제되어서는 안 되는 경우를 제외한다면, 스크린을 예약 할당하는 것은 상기 스크린과 연관된 모든 'HScreenDevice' 인스턴스들을 예약 할당하는 것과 동일하게 간주된다.
스크린을 예약 할당할 때, 상기 스크린의 일부 'HScreenDevice'가 또 다른 어플리케이션에 의해 이미 예약 할당되었다면, 상기 예약 할당은 상기 스크린에 예약 할당을 허용하기 전에 (MSM 구현에 의해) 성공적으로 해제된다. 해제되지 않거나 해제될 수 없다면, 상기 스크린을 예약 할당하려는 시도는 실패해야 한다.(즉, 'reserveScreen' 메소드(1380)가 '거짓' 값을 반환하여야 한다.)
스크린을 예약 할당할 때, 해당 스크린의 일부 'HScreenDevice'이 예약 할당하는 어플리케이션에 의해 이미 예약 할당되었다면, 상기 예약 할당은 전체 화면의 성공적인 예약 할당에 내재적으로 포함되어야 한다.
'reserveScreen' 메소드(1380)를 이용하여 스크린을 예약 할당하려는 시도가 성공한다면, 즉 'reserveScreen' 메소드(1380)가 '참' 값을 반환한다면, 해당 스크린의 모든 'HScreenDevice' 인스턴스의 'getClient()' 메소드는 ('HScreen'이 구체적으로 구현되면서) 'org.ocap.ui.MultiScreenConfigurableContext' 인터페이스(1210)에 의해 정의된 'getClient()' 메소드(1362)와 동일한 값을 반환하여야 한다.
해당 스크린이 이전에 예약 할당되지 않고, 스크린 상의 'reserveScreen' 메소드(1380)의 호출로 인해 스크린이 예약 할당되면, 'reserveScreen' 메소드(1380)에 의해 값이 반환되기 이전에, 'MultiScreenResourceEvent.MULTI_SCREEN_RESOURCE_SCREEN_RESERVED' 이벤트가 생성되어야 한다.
호출 어플리케이션이 해당 스크린에 대한 예약 할당을 이미 유지하고, 지정된 'client'와 'requestData' 인자가, 호출 어플리케이션이 이전에 예약 할당이 허용된 때 지정된 'client'와 'requestData' 인자와 동일하다면, 'reserveScreen' 메소드(1380)는 부수 효과가 없이 '참' 값을 반환한다. 그러나, 호출 어플리케이션이 이미 해당 스크린에 예약 할당해 놓고, 지정된 'client'와 'requestData' 인자가, 호출 어플리케이션이 이전에 예약 할당 허용된 때 지정된 'client'와 'requestData' 인자와 다르다면, (ⅰ) 상기 지정된 'client'와 'requestData' 인자는 이전에 지정된 'client'와 'requestData' 인자로 교체되어야 하며, (ⅱ) 호출 어플리케이션은 예약 할당을 유지하여야 하고, (ⅲ) 'reserveScreen' 메소드(1380)는 '참' 값을 반환하여야 한다.
'client' 파라미터는 'ResourceClient' 인스턴스이다. 'requestData' 파라미터는 'null' 값이거나 'java.rmi.Remote' 인터페이스를 구현하는 'Object' 인스턴스이다.
스크린의 기저 리소스들이 성공적으로 예약지정된다면, 'reserveScreen' 메소드(1380)는 '참' 값을 반환하고, 그렇지 않으면 '거짓' 값을 반환한다.
'reserveScreen' 메소드(1380)는 MSM I01 버전으로부터 적용되며, 'Remote'가 참고된다.
'releaseScreen' 메소드(1370)는 'void releaseScreen()'로 선언되며, 스크린의 기저 리소스들을 세부적으로 예약 해제한다.
호출 어플리케이션이 해당 스크린에 대한 예약 할당을 유지하지 않는다면, 'releaseScreen' 메소드(1370)가 반응하면 안 된다.
해당 스크린이 이전에 예약 할당되었고 'releaseScreen' 메소드(1370)의 호출이 해당 스크린이 더 이상 예약 할당되지 않도록(예약 해제되도록) 하면, 'releaseScreen' 메소드(1370)가 값을 반환하기 이전에 'MultiScreenResourceEvent.MULTI_SCREEN_RESOURCE_SCREEN_RELEASED' 이벤트가 생성되어야 한다.
'releaseScreen' 메소드(1370)는 MSM I01 버전으로부터 적용된다.
도 14a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스의 정의를 도시한다.
'MultiScreenConfiguration' 인터페이스가 'public interface MultiScreenConfiguration'로 선언된다.
OCAP 호스트 플랫폼에 의해 구현되는 'MultiScreenConfiguration' 인터페이스는 스크린 설정에 대한 변경을 감시하기 위한 메커니즘 뿐만 아니라 불연속적인 스크린 설정에 대한 정보를 제공한다.
MSM 구현은 그 설정 타입이 'SCREEN_CONFIGURATION_DISPLAY'인 적어도 하나의 멀티스크린 설정을 지원하여야 한다.
MSM 구현은 그 설정 타입이 'SCREEN_CONFIGURATION_NON_PIP'인 적어도 하나의 멀티스크린 설정을 지원하여야 한다.
MSM 구현이 OCAP을 작동하는 동안 PIP 기능성을 구현하고 PIP 스크린의 재생을 허용한다면, MSM 구현이 멀티스크린 설정 'SCREEN_CONFIGURATION_PIP'을 지원하여야 한다.
MSM 구현이 OCAP을 작동하는 동안 POP 기능성을 구현하고 POP 스크린의 재생을 허용한다면, MSM 구현이 멀티스크린 설정 'SCREEN_CONFIGURATION_POP'을 지원하여야 한다.
MSM 구현이, 비일반(non-general) 멀티스크린 설정에 의해 이하 내재적으로 지정되지 않은 불연속적인 설정에서 PIP, POP, 또는 OVERLAY 기능성을 구현한다면, MSM 구현은 각각의 멀티스크린 설정을 나타내는 설정 타입 'SCREEN_CONFIGURATION_GENERAL'의 하나 이상의 멀티스크린 설정들을 지원하여야 한다.
'org.ocap.ui'의 'MultiScreenConfiguration' 인터페이스(1220)는 MSM I01 버전으로부터 적용된다.
도 14b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스의 필드를 도시한다.
'org.ocap.ui'의 'MultiScreenConfiguration' 인터페이스(1220)의 필드(1400)는, 'static java.lang.String SCREEN_CATEGORY_DISPLAY'(1402), 'static java.lang.String SCREEN_CATEGORY_GENERAL'(1404), 'static java.lang.String SCREEN_CATEGORY_MAIN'(1406), 'static java.lang.String SCREEN_CATEGORY_NONE'(1408), 'static java.lang.String SCREEN_CATEGORY_OVERLAY'(1410), 'static java.lang.String SCREEN_CATEGORY_PIP'(1412), 'static java.lang.String SCREEN_CATEGORY_POP'(1414), 'static java.lang.String SCREEN_CONFIGURATION_DISPLAY'(1416), 'static java.lang.String SCREEN_CONFIGURATION_GENERAL'(1418), 'static java.lang.String SCREEN_CONFIGURATION_NON_PIP'(1420), 'static java.lang.String SCREEN_CONFIGURATION_PIP'(1422), 및 'static java.lang.String SCREEN_CONFIGURATION_POP'(1424) 중 적어도 하나를 포함한다.
'SCREEN_CONFIGURATION_DISPLAY' 필드(1416)는 'static final java.lang.String SCREEN_CONFIGURATION_DISPLAY'로 선언된다. 'MultiScreenConfiguration'이 하나 이상의 디스플레이 스크린과 연관되고, 플랫폼별 멀티스크린 설정으로 사용되기 위한 후보라면, 'MultiScreenConfiguration'의 설정 타입은 'SCREEN_CONFIGURATION_DISPLAY'(1416)이다.
'SCREEN_CONFIGURATION_DISPLAY' 설정 타입(1416)의 초기 디폴트 스크린은 'getScreens(SCREEN_CATEGORY_MAIN)'에 의해 반환되는 첫 번째 스크린이어야 한다. 만약 설정 중에 'SCREEN_CATEGORY_MAIN' 카테고리(1406)로 분류된(categorized) 스크린이 없다면, 'SCREEN_CONFIGURATION_DISPLAY' 설정 타입(1416)의 초기 디폴트 스크린은 'getScreens()'에 의해 반환된 첫 번째 스크린이어야 한다.
'SCREEN_CONFIGURATION_DISPLAY' 필드(1416)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CONFIGURATION_NON_PIP' 필드(1420)는 'static final java.lang.String SCREEN_CONFIGURATION_NON_PIP'로 선언된다. 'MultiScreenConfiguration'이 그 카테고리가 'SCREEN_CATEGORY_MAIN'(1406)인 단 하나의 스크린과 연관된다면, 그 설정 타입은 'SCREEN_CONFIGURATION_NON_PIP'(1420)이다.
'SCREEN_CONFIGURATION_NON_PIP' 설정 타입(1420)의 초기 디폴트 스크린은 'getScreens(SCREEN_CATEGORY_MAIN)'에 의해 반환되는 첫 번째 스크린이어야 한다.
'SCREEN_CONFIGURATION_NON_PIP' 설정 타입(1420)의 카테고리로 분류된 'MultiScreenConfiguration' 인스턴스는 둘 이상의 디스플레이 스크린을 포함하면 안 된다.
'SCREEN_CONFIGURATION_NON_PIP' 필드(1420)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CONFIGURATION_PIP' 필드(1422)는 'static final java.lang.String SCREEN_CONFIGURATION_PIP'로 선언된다. 'MultiScreenConfiguration'이 (ⅰ) 단일 디스플레이 스크린의 전체 영역에 맵핑된 디폴트 'z-order'가 '0'인 하나의 로지컬 스크린에 연관되고, (ⅱ) 동일한 디스플레이 스크린에 맵핑된 디폴트 'z-order'가 '1'인, 서로 교차하지 않는(non-intersecting) 하나 이상의 로지컬 스크린들과 연관된다면, 그 설정 타입이 'SCREEN_CONFIGURATION_PIP'(1422)이다.
'SCREEN_CONFIGURATION_PIP' 설정 타입(1422)의 초기 디폴트 스크린이 'getScreens(SCREEN_CATEGORY_MAIN)'에 의해 반환된 첫 번째 스크린이어야 하고, 상기 설정에 'SCREEN_CATEGORY_MAIN(1406)'으로 카테고리 분류된 스크린이 없다면, 'getScreens()'에 의해 반환된 첫 번째 스크린이어야 한다.
'SCREEN_CONFIGURATION_PIP' 설정 타입(1422)의 카테고리로 분류된 'MultiScreenConfiguration' 인스턴스는 둘 이상의 디스플레이 스크린을 포함하면 안된다.
'SCREEN_CONFIGURATION_PIP' 필드(1422)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CONFIGURATION_POP' 필드(1424)는 'static final java.lang.String SCREEN_CONFIGURATION_POP'로 선언된다. 'MultiScreenConfiguration'이, 그 디폴트 디스플레이 영역들이 (연합하여) 단일 디스플레이 스크린의 전체 영역을 덮는 디폴트 'z-order'가 '0'인, 서로 교차하지 않는 둘 이상의 로지컬 스크린들과 연관된다면, 그 설정 타입이 'SCREEN_CONFIGURATION_POP(1424)'이다.
'SCREEN_CONFIGURATION_POP' 설정 타입(1424)의 초기 디폴트 스크린은, 'getScreens(SCREEN_CATEGORY_POP)'에 의해 반환된 첫 번째 스크린이어야 하고, 상기 설정에 'SCREEN_CATEGORY_POP'(1414)으로 카테고리 분류된 스크린이 없다면, 'getScreens()'에 의해 반환된 첫 번째 스크린이어야 한다.
'SCREEN_CONFIGURATION_POP' 설정 타입(1424)을 가지면서 카테고리 분류된 'MultiScreenConfiguration' 인스턴스는 둘 이상의 디스플레이 스크린을 포함하면 안 된다.
'SCREEN_CONFIGURATION_POP' 필드(1424)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CONFIGURATION_GENERAL' 필드(1418)는 'static final java.lang.String SCREEN_CONFIGURATION_GENERAL'로 선언된다. 'MultiScreenConfiguration'이, 다른 기정 스크린 설정 타입들 중 하나로 카테고리 분류될 수 없다면, 그 설정 타입은 'SCREEN_CONFIGURATION_GENERAL'(1418)이다.
'SCREEN_CONFIGURATION_GENERAL' 설정 타입(1418)의 초기 디폴트 스크린이 'getScreens(SCREEN_CATEGORY_MAIN)'에 의해 반환되는 첫 번째 스크린이어야 하고, 또는 상기 구상에 SCREEN_CATEGORY_GENERAL(1404)로 카테고리 분류된 스크린이 없다면 'getScreens()'에 의해 반환되는 첫 번째 스크린이어야 한다.
'SCREEN_CONFIGURATION_GENERAL' 설정 타입(1418)의 카테고리로 분류되는 'MultiScreenConfiguration' 인스턴스는 둘 이상의 디스플레이 스크린을 포함하면 안 된다.
'SCREEN_CONFIGURATION_GENERAL' 필드(1418)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CATEGORY_NONE' 필드(1408)는 'static final java.lang.String SCREEN_CATEGORY_NONE'로 선언된다. 'HScreen' 인스턴스가 다른 소정 카테고리와 연관되지 않는다면, 그 카테고리는 'SCREEN_CATEGORY_NONE'(1408)이다.
'SCREEN_CATEGORY_NONE' 설정 타입(1408)의 카테고리로 분류되는 'MultiScreenConfiguration' 인스턴스는 둘 이상의 디스플레이 스크린을 포함하면 안 된다.
'SCREEN_CATEGORY_NONE 필드'(1408)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CATEGORY_DISPLAY' 필드(1402)는 'static final java.lang.String SCREEN_CATEGORY_DISPLAY'로 선언된다. 디스플레이 'HScreen' 인스턴스가 넌-메인 스크린으로 특징지어진다면, 그 카테고리는 'SCREEN_CATEGORY_DISPLAY'(1402)이다. 이 카테고리에 지정된 디스플레이 스크린은 'HBackgroundDevice' 또는 'HVideoDevice'에 의해 차지되면 안 되지만, 오버레이 동작을 하는 하나 이상의 'HGraphicsDevice' 인스턴스들에 의해 차지될 수는 있다.
'SCREEN_CATEGORY_DISPLAY'(1402)로 카테고리 분류되는 디스플레이 'HScreen' 인스턴스는, 그 'HGraphicsDevice' 인스턴스들이 존재한다면, 그 'HGraphicsDevice' 인스턴스들이 디스플레이 스크린에 맵핑되는 모든 로지컬 스크린들을 오버레이되어야 한다는 예외적 특성을 갖는다. 모든 디스플레이 스크린에 대해 'MultiScreenContext.getZOrder()' 메소드가 '0'을 반환함에도 불구하고, 이 성질은 준수되어야 한다.
전술된 예외적 특성은 (ⅰ) 자막 오버레이가 모든 다른 컨텐츠 위에 표현되는 레가시 디바이스 시나리오들(legacy device scenarios), 및 (ⅱ) 오버레이 스크린을 별개의 로지컬 스크린로 취급하기 보다는, 오버레이 스크린이 해당 디스플레이 스크린의 완전한 'HGraphicsDevice'로 간주되는 설정들을 지원하기 위함이다.'
'SCREEN_CATEGORY_DISPLAY' 필드(1402)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CATEGORY_MAIN' 필드(1406)는 'static final java.lang.String SCREEN_CATEGORY_MAIN'로 선언된다. 디스플레이 'HScreen' 인스턴스 또는 로지컬 'HScreen' 인스턴스이 메인 스크린으로 특징지어진다면, 그 카테고리는 'SCREEN_CATEGORY_MAIN'(1406)이다. 이 카테고리에 지정된 로지컬 스크린은 일부 디스플레이 스크린의 전체 영역에 맵핑되어야 하고, 디폴트 'z-order'를 '0'으로 지정되어야 한다.
'SCREEN_CATEGORY_MAIN' 필드(1406)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CATEGORY_PIP' 필드(1412)는 'static final java.lang.String SCREEN_CATEGORY_PIP'로 선언된다. 로지컬 'HScreen' 인스턴스가 픽처-인-픽터(PIP) 스크린으로 특성지어진다면, 그 카테고리가 'SCREEN_CATEGORY_PIP'(1412)이다. 이 카테고리로 지정된 로지컬 스크린은 일부 디스플레이 스크린의 전체 영역에 맵핑되어서는 안 되고, 스크린 z-order 0으로 지정되면 안 되며, 일부 스크린이 'SCREEN_CATEGORY_MAIN' 카테고리(1406)로 지정된 설정에 함께 존재하여야 한다.
'SCREEN_CATEGORY_PIP' 필드(1412)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CATEGORY_POP' 필드(1414)는 'static final java.lang.String SCREEN_CATEGORY_POP'로 선언된다. 로지컬 'HScreen' 인스턴스가 픽처-아웃사이드-픽처(POP) 스크린으로 특징지어진다면, 그 카테고리는 'SCREEN_CATEGORY_POP'(1414)이다. 이 카테고리로 지정된 로지컬 스크린은, 일부 디스플레이 스크린의 전체 영역에 맵핑되면 안 되고, 일부 스크린이 'SCREEN_CATEGORY_MAIN' 카테고리(1406)에 지정된 설정에 함께 존재하면 안 되며, 일부 다른 스크린이 'SCREEN_CATEGORY_POP' 카테고리(1414)에 지정된 설정에 함께 존재하여야 한다.
'SCREEN_CATEGORY_POP' 필드(1414)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CATEGORY_OVERLAY' 필드(1410)는 'static final java.lang.String SCREEN_CATEGORY_OVERLAY'로 선언된다. 로지컬 'HScreen' 인스턴스가 오버레이 스크린으로 특징지어지면, 그 카테고리는 'SCREEN_CATEGORY_OVERLAY'(1410)이다. 이 카테고리로 지정된 로지컬 스크린은 일부 디스플레이의 전체 영역에 맵핑되어야 하고, 'SCREEN_CATEGORY_MAIN'(1406), 'SCREEN_CATEGORY_PIP'(14120 및 SCREEN_CATEGORY_POP(1414) 중 하나의 카테고리에 연관된 스크린보다 큰 디폴트 'z-order'가 지정되어야 하며, 백그라운드 또는 명백한 비디오 평면(HVideoDevice)을 포함하면 안 된다.
전술된 요건에도 불구하고, 오버레이 스크린은, 그 그래픽 평면(들 중 하나)에서 컴포넌트(component)에 기초한 비디오를 재생하기 위해 내재된 비디오 평면(HVideoDevice)의 리소스들을 사용할 수 있다.
'SCREEN_CATEGORY_OVERLAY' 필드(1410)는 MSM I01 버전으로부터 적용된다.
'SCREEN_CATEGORY_GENERAL' 필드(1404)는 'static final java.lang.String SCREEN_CATEGORY_GENERAL'로 선언된다. 로지컬 'HScreen' 인스턴스가 (예를 들어, 그 사이즈, 위치 또는 'z-order'면에서) 설정될 수 있어, 다른 스크린 카테고리들 중 둘 이상의 지정을 제안했던 모드에서 동작할 수 있다면, 그 카테고리는 'SCREEN_CATEGORY_GENERAL'(1404)일 수 있다. 터미널 디바이스가 정하는 하나(이상)의 설정 가능한 속성에 대한 정하는 고유의 한계의 정도가 아니면, 'SCREEN_CATEGORY_GENERAL' 카테고리(1404)로 지정된 로지컬 스크린은 사이즈, 위치, z-order 또는 다른 설정 가능한 속성들에 대해 제한되어서는 안 된다.
'SCREEN_CATEGORY_GENERAL' 필드(1404)는 MSM I01 버전으로부터 적용된다.
도 14c 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스의 메소드를 도시한다.
'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스(1220)의 메소드(1450)는, 'java.lang.String getConfigurationType()'(1452), 'org.havi.ui.HScreen getDefaultServiceContextScreen()'(1454), 'org.havi.ui.HScreen[] getScreens()'(1456), 'org.havi.ui.HScreen[] getScreens(java.lang.String category)'(1458), 'boolean hasOverlayScreen()'(1460), 'boolean isScreenInConfiguration(org.havi.ui.HScreen screen)'(1462), 및 'void setDefaultServiceContextScreen'(1464) 중 적어도 하나를 포함한다.
'getConfigurationType' 메소드(1452)는 'java.lang.String getConfigurationType()'로 선언되며, 해당 설정의 스크린 설정 타입을 획득한다. 하나 이상의 비일반(non-general) 설정 타입이 적용되거나 설정 타입을 모르거나 설정 타입이 결정될 수 없다면, 'getConfigurationType' 메소드(1452)는 'SCREEN_CONFIGURATION_GENERAL' 값(1418)을 반환하여야 한다.
'getConfigurationType' 메소드(1452)에 의해, (ⅰ) 'SCREEN_CONFIGURATION_DISPLAY'(1416), 'SCREEN_CONFIGURATION_NON_PIP'(1420), 'SCREEN_CONFIGURATION_PIP'(1422), 'SCREEN_CONFIGURATION_POP'(1424), 'SCREEN_CONFIGURATION_GENERAL'(1418) 중 하나의 인자, 또는 (ⅱ) 플랫폼에 의존적인 설정을 나타내고, 접두어 'x-'로 시작되는 스트링 값, 중 어느 하나인 스트링이 반환된다.
'getConfigurationType' 메소드(1452)는 MSM I01 버전으로부터 적용된다.
'getScreens()' 메소드(1456)는 'org.havi.ui.HScreen[] getScreens()'로 선언되며, 멀티스크린 설정과 연관된 억세스 가능한 스크린들을 획득한다.
'getScreens()' 메소드(1456)에 의해 반환된 주어진 'HScreen' 인스턴스의 기저 리소스들은 또 다른 멀티스크린 설정에 포함된 'HScreen' 인스턴스와 공유될 수 있다. 그러나 상기 공유된 리소스들은 소정 시간에 하나의 멀티스크린 설정에서만 활성 상태여야 한다. 'HScreen' 인스턴스의 반환된 어레이의 엔트리의 순서는 구현에 의존적이다.
반환된 어레이의 별개의 두 엔트리의 값들, S1 및 S2,과 'MultiScreenManager', MSM,의 싱글턴 인스턴스의 경우, 'getScreens()' 메소드(1456)가 값을 반환하는 시점과 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트가 발생되고 전달되는 시점 사이의 기간 동안 후술되는 제한 요건이 만족된다.
- 'MSM.isEmptyScreen(S1)' 메소드는 '거짓' 값을 반환하여야 한다.
- 'MSM.isEmptyScreen(S2)' 메소드는 '거짓' 값을 반환하여야 한다.
- 'MSM.sameResources(S1,S2)' 메소드는 '거짓' 값을 반환하여야 한다.
'MonitorAppPermission("multiscreen.configuration")'를 갖지 않은 어플리케이션에 의해 호출된다면, 어플리케이션에 의해 억세스 가능한 'ServiceContext' 인스턴스와 연관되지 않은 멀티스크린 설정의 스크린들은 반환되어서는 안 된다. 그렇지 않으면, 해당 설정의 모든 억세스 가능한 스크린들이 반환되어야 한다.
어플리케이션의 라이프사이클 동안, 이하 제한된 경우를 제외하면, MSM 구현은 스크린들을 멀티스크린 설정에 부가하거나 멀티스크린 설정으로부터 제거할 수 있으며, 이 경우 각각 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED' 이벤트 또는 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED' 이벤트가 생성되어야 한다.
스크린은, 현재 활성화된 플랫폼별 멀티스크린 설정 또는 일부 현재 활성 디스플레이별 멀티스크린 설정인 멀티스크린 설정에 부가되거나 상기 멀티스크린 설정으로부터 제거되어서는 안 된다.
스크린들을 멀티스크린 설정에 부가되거나 멀티스크린 설정으로부터 제거하기 위해 MSM 구현은, 상기 멀티스크린 설정이 더 이상 현재 활성 멀티스크린 설정이 아닐 때까지 대기하여야 한다.
'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED' 이벤트 또는 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED' 이벤트가 발생되지 않는 기간 동안, 반환된 HScreen 인스턴스들 및 상기 반환된 인스턴스들의 순서는 주어진 어플리케이션에 대해 변경되어서는 안 된다.
MSM 구현은, 그 기저 리소스들이 일부 종결되지 않은 어플리케이션의 디폴트 HScreen 인스턴스의 동일한 기저 리소스들을 나타내는 HScreen 인스턴스를 해당 멀티스크린 설정으로부터 제거(또는 제거를 보고)하는 효과가 가지는 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED' 이벤트를 제거하거나 발생시켜서는 안 된다.
'getScreens()' 메소드(1456)는 'HScreen' 어레이를 반환한다. 반환된 'HScreen' 어레이는 빈 어레이일 수도 있다.
'getScreens()' 메소드(1456)는 MSM I01 버전으로부터 적용된다.
'getScreens(String)' 메소드(1458)는 'org.havi.ui.HScreen[] getScreens(java.lang.String category)'로 선언되며, 주어진 카테고리를 갖는 모든 억세스 가능한 스크린들을 획득한다.
'getScreens(String)' 메소드(1458)는 아래 경우를 제외하고 'getScreens()' 메소드(1456)와 동일한 기능을 갖는다.
- 'category'가 'null' 값이 아니라면 지정된 카테고리로 지정된 스크린들만을 반환하고, 그런 스크린이 없다면 빈 'HScreen' 어레이를 반환한다. 'category' 가 'null' 값이라면 'getScreens()' 메소드(1456)와 동일한 값이 반환된다.
'category' 파라미터는 (ⅰ) 'null' 값, (ⅱ) 'SCREEN_CATEGORY_NONE'(1408), 'SCREEN_CATEGORY_DISPLAY'(1402), 'SCREEN_CATEGORY_MAIN'(1406), 'SCREEN_CATEGORY_PIP'(1412), 'SCREEN_CATEGORY_POP'(1414), 'SCREEN_CATEGORY_OVERLAY'(1410), 'SCREEN_CATEGORY_GENERAL'(1404) 중 하나, 및 (ⅲ) 스크린 카테고리로 미리 정의되지 않았지만 'getScreenCategory(HScreen)' 메소드에 의해 반환될 수 있는 플랫폼에 의존적인 스트링 값, 중 하나이다.
'getScreens(String)' 메소드(1458)는 'HScreen' 어레이를 반환한다. 'getScreens(String)' 메소드(1458)에 의해 반환된 'HScreen'는 빈 어레이일 수도 있다.
'getScreens(String)' 메소드(1458)는 MSM I01 버전으로부터 적용된다.
'hasOverlayScreen()' 메소드(1460)는 'boolean hasOverlayScreen()'로 선언되며, 해당 설정에 연관된 스크린들이 오버레이 스크린, 즉 그 카테고리가 'SCREEN_CATEGORY_OVERLAY'(1410)인 스크린,을 포함하는지 여부를 결정한다.
'hasOverlayScreen()' 메소드(1460)는, 'getScreens(SCREEN_CATEGORY_OVERLAY)'가 비지 않은 어레이를 반환한다면 '참' 값을 반환하고, 그렇지 않으면 '거짓' 값을 반환한다.
'hasOverlayScreen()' 메소드(1460)는 MSM I01 버전으로부터 적용된다.
'getDefaultServiceContextScreen()' 메소드(1454)는 'org.havi.ui.HScreen getDefaultServiceContextScreen()'로 선언되며, 해당 설정의 디폴트 서비스 컨텍스트 연관 스크린을 획득한다.
멀티스크린 설정의 디폴트 서비스 컨텍스트 연관 스크린은, 스크린과 'ServiceContext' 인스턴스를 연관하는 방법을 결정하기 위해 더 이상의 세부 정보가 사용하지 않은 경우 멀티스크린 설정이 활성 상태가 될 때, 'ServiceContext' 인스턴스들이 연관되는 스크린이다.
이하의 제한 요건이 적용된다.
1. 해당 멀티스크린 설정이 플랫폼별 디스플레이 멀티스크린 설정인 경우, 디폴트 서비스 컨텍스트 연관 스크린은, 상기 멀티스크린 설정과 연관된 일부 디스플레이 스크린의 디스플레이별 멀티스크린 설정과 연관된 스크린이어야 한다.
2. 그렇지 않으면, 해당 멀티스크린 설정이 디스플레이별 멀티스크린 설정이라면, 디폴트 서비스 컨텍스트 연관 스크린은 상기 멀티스크린 설정과 연관되는 디스플레이 스크린 또는 로지컬 스크린이어야 한다.
'getDefaultServiceContextScreen()' 메소드(1454)는, 해당 설정을 위한 디폴트 서비스 컨텍스트 스크린으로 기능하는 'HScreen' 인스턴스를 반환한다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'getDefaultServiceContextScreen()' 메소드(1454)는 'java.lang.SecurityException'를 발생시킨다.
'getDefaultServiceContextScreen()' 메소드(1454)는 MSM I01 버전으로부터 적용된다.
'setDefaultServiceContextScreen' 메소드(1464)는 'void setDefaultServiceContextScreen(org.havi.ui.HScreen screen)'로 선언되며, 해당 설정의 디폴트 서비스 컨텍스트 연관 스크린을 설정한다.
멀티스크린 설정의 디폴트 서비스 컨텍스트 연관 스크린은, 스크린과 'ServiceContext' 인스턴스를 연관하는 방법을 결정하기 위해 더 이상의 세부 정보가 사용하지 않은 경우 멀티스크린 설정이 활성 상태가 될 때, 'ServiceContext' 인스턴스들이 연관되는 스크린이다.
'screen' 파라미터는 해당 멀티스크린 설정을 위한 디폴트 서비스 컨텍스트 연관 스크린으로 지명된 'HScreen' 인스턴스이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'setDefaultServiceContextScreen' 메소드(1464)는 'java.lang.SecurityException'를 발생시킨다. 'getDefaultServiceContextScreen()'(1454)에서 전술된 제한 요건이 만족되지 않는다면, 'setDefaultServiceContextScreen' 메소드(1464)는 'java.lang.IllegalArgumentException'를 발생시킨다.
'setDefaultServiceContextScreen' 메소드(1464)는 MSM I01 버전으로부터 적용된다.
'isScreenInConfiguration(HScreen)' 메소드(1462)는 'boolean isScreenInConfiguration(org.havi.ui.HScreen screen)'로 선언된다. 'isScreenInConfiguration(HScreen)' 메소드(1462)는, 지정된 스크린의 기저 리소 스들이 해당 설정과 연관된 스크린들에 포함된 'HScreen' 인스턴스에 의해 나타내지는지 여부를 결정한다.
'screen' 파라미터는 'HScreen' 파라미터이다.
기저 리소스들이 지정된 스크린이 해당 설정에 포함된 'HScreen' 인스턴스에 의해 나타내어진다면, 'isScreenInConfiguration(HScreen)' 메소드(1462)는 '참' 값을 반환한다. 그렇지 않으면 '거짓' 값을 반환한다.
'isScreenInConfiguration(HScreen)' 메소드(1462)는 MSM I01 버전으로부터 적용된다.
도 15a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenContext' 인터페이스의 정의를 도시한다.
'org.ocap.ui'의 'MultiScreenContext' 인터페이스(1230)의 알려진 모든 서브인터페이스(All Known Subinterfaces)는 'MultiScreenConfigurableContext'를 포함하며, 'public interface MultiScreenContext'로 선언된다.
'MultiScreenContext' 인터페이스(1230)는 이하를 달성하기 위한 툴들를 제공한다.
1. 'VideoOutputPort'과 직접 연관된 'HScreen' 인스턴스들과, 로지컬 맵핑 프로세스를 통해 'VideoOutputPort'과 간적접으로 연관된 'HScreen' 인스턴스들를 구별한다. 즉 'HScreen'이 디스플레이 스크린인지 로지컬 스크린인지 여부를 판별한다.
2. 'HScreen' 인스턴스의 기저 리소스의 고유 플랫폼 식별자를 판별한다.
3. 'MultiScreenConfiguration'에서 'HScreen'에 지정된 카테고리를 판별한다.
4. 로지컬 'HScreen'이 표현되는 디스플레이 'HScreen'에서의 영역(범위), 가시성, 'z-order'를 포함하는 로지컬 'HScreen'들의 디스플레이 'HScreen'들로의 맵핑 관계를 판별한다.
5. 'HScreen' 내에서 'HScreenDevice'들의 'z-order'를 판별한다.
6. 'HScreen'과 연관된 'ServiceContext'들을 판별한다.
7. 디스플레이 'HScreen'들과 해당 'VideoOutputPort' 인스턴스들의 연관 관계를 판별한다.
8. 그 재생되는 오디오가 'HScreen'의 오디오 소스들을 구성하는 'HScreenDevice'들을 판별한다.
9. 디스플레이 'HScreen'의 현재 오디오 포커스 지정을 판별한다.
10. 해당 'MultiScreenContext'의 상태 변경 또는 해당 인터페이스를 구현하는 'HScreen' 인스턴스 내의 소정 변경들의 통지를 판별한다.
11. 디스플레이 스크린의 디스플레이별 멀티스크린 설정의 변경들의 통지를 획득한다.
12. 디스플레이 스크린과 사용될 수 있는 디스플레이별 멀티스크린 설정들을 판별한다.
13. 디스플레이 스크린의 현재 활성 디스플레이별 멀티스크린 설정을 획득한다.
OCAP 구현이 OCAP 멀티스크린 매니저 익스텐션(OCAP Multiscreen Manager(MSM) Extension)을 지원하지 않거나, 'MultiScreenContext' 인터페이스(1230)를 지원하지 않는다면, OCAP 어플리케이션은, 'HScreen'의 작동이 그 메소드들이 이하와 같이 동작되는 'MultiScreenContext' 인터페이스를 구현하는 'HScreen' 인스턴스와 동일하다고 가정할 수 있다.
- 'getScreenType()' 메소드는 'SCREEN_TYPE_DISPLAY' 값을 반환한다;
- 'getID()' 메소드는 플랫폼에 의존적인 (빈 스트링일 수 있는) 스트링을 반환한다;
- 'getScreenCategory()' 메소드는 'main' 스트링을 반환한다;
- 'getVisible()' 메소드는 '참' 값을 반환한다;
- 'getZOrder()' 메소드는 '0'을 반환한다;
- 'getZOrder(HScreenDevice device)' 메소드는, 'HScreen' 인스턴스에 대해 'HScreen.getHBackgroundDevices()' 메소드, 'HScreen.getHVideoDevices()' 메소드, 'HScreen.getHGraphicsDevices()' 메소드를 호출한 결과를 순서대로 연쇄시킴으로써 생성된 'HScreenDevice' 인스턴스들의 어레이 내의 'device' 파라미터의 어레이 인덱스를 반환한다. 'device' 파라미터가 상기 어레이에 존재하지 않는 경우 'IllegalArgumentException'가 발생된다.
- 'getAudioSources()' 메소드는, 'HScreen' 인스턴스에 대해 'HScreen.getHBackgroundDevices()' 메소드, 'HScreen.getHVideoDevices()' 메소드, 'HScreen.getHGraphicsDevices()' 메소드를 호출한 결과를 순서대로 연쇄 시킴으로써 생성된 'HScreenDevice' 인스턴스들의 어레이를 반환한다;
- 'getAudioFocus()' 메소드는 해당 'HScreen' 인스턴스를 반환한다;
- 'getOutputPorts()' 메소드는 플랫폼 상에서 이용 가능한 모든 'VideoOutputPort'들을 포함하는 어레이를 반환한다;
- 'getDisplayScreen()' 메소드는 해당 'HScreen' 인스턴스를 반환한다;
- 'getDisplayArea()' 메소드는 'new HScreenRectangle(0,0,1,1)'를 반환한다;
- 'getContexts()' 메소드는 현재 어플리케이션에 의해 억세스 가능한 모든 'ServiceContext'들을 포함하는 어레이를 반환한다.
MSM 구현은 모든 'HScreen' 인스턴스에 대한 'MultiScreenContext' 인터페이스(1230)를 지원하여야 한다.
'org.ocap.ui'의 'MultiScreenContext' 인터페이스(1230)는 MSM I01 버전으로부터 적용된다.
도 15b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenContext' 인터페이스의 필드를 도시한다.
'org.ocap.ui'의 'MultiScreenContext' 인터페이스(1230)의 필드(1500)는, 'static int SCREEN_TYPE_DISPLAY'(1502), 및 'static int SCREEN_TYPE_LOGICAL(1504)' 중 적어도 하나를 포함한다.
'SCREEN_TYPE_DISPLAY' 필드(1502)는 'static final int SCREEN_TYPE_DISPLAY'로 선언된다. 'HScreen'이 'VideoOutputPort'에 직접적으로 연관되고, 'HSceen'의 범위가 'VideoOutputPort'로부터 재생되는 비디오 래스터의 범위에 맵핑된다면, 'HScreen'의 타입은 'SCREEN_TYPE_DISPLAY'이며, 디스플레이 'HScreen'이라 지칭된다.
'SCREEN_TYPE_DISPLAY' 필드(1502)는 MSM I01 버전으로부터 적용된다.
'SCREEN_TYPE_LOGICAL' 필드(1504)는 'static final int SCREEN_TYPE_LOGICAL'로 선언된다. 'HScreen'이 'VideoOutputPort'에 직접적으로 연관되지 않거나, 'HSceen'의 범위가 'VideoOutputPort'로부터 재생되는 비디오 래스터의 서브영역에 맵핑된다면, 'HScreen'의 타입은 'SCREEN_TYPE_LOGICAL'이며, '로지컬 HScreen'이라 지칭된다. 로지컬 'HScreen'은 디스플레이 'HScreen'과 연관될 수 있다. 로지컬 'HScreen'이 디스플레이 'HScreen'과 연관되지 않는다면, 로지컬 'HScreen'과 연관된 어떤 'ServiceContext'에 의해서도 시각적 또는 청각적인 컨텐츠가 재생되어서는 안 된다.
디스플레이 'HScreen'과 연관되지 않은 로지컬 'HScreen'은, 재생이 아닌 다른 목적으로 컨텐츠를 복호화하고 재생할 수 있다. 예를 들면 차후의 재생을 위해 'ServiceContext'으로부터의 컨텐츠가 기록될 수 있다.
'SCREEN_TYPE_LOGICAL' 필드(1504)는 MSM I01 버전으로부터 적용된다.
도 15c 및 15d는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenContext' 인터페이스의 메소드를 도시한다.
'org.ocap.ui'의 'MultiScreenContext' 인터페이스(1230)의 메소드(1550)는, 'void addMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'(1552), 'void addScreenContextListener(MultiScreenContextListener listener)'(1554), 'org.havi.ui.HScreen getAudioFocus()'(1556), 'org.havi.ui.HScreenDevice[] getAudioSources()'(1558), 'org.havi.ui.HScreenRectangle getDisplayArea()'(1560), 'org.havi.ui.HScreen getDisplayScreen()'(1562), 'java.lang.String getID()'(1564), 'MultiScreenConfiguration getMultiScreenConfiguration()'(1566), 'MultiScreenConfiguration[] getMultiScreenConfigurations()'(1568), 'MultiScreenConfiguration[] getMultiScreenConfigurations(java.lang.String screenConfigurationType)'(1570), 'org.ocap.hardware.VideoOutputPort[] getOutputPorts()'(1572), 'java.lang.String getScreenCategory()'(1574), 'int getScreenType()'(1576), 'javax.tv.service.selection.ServiceContext[] getServiceContexts()'(1578), 'boolean getVisible()'(1580), 'int getZOrder()'(1582), 'int getZOrder(org.havi.ui.HScreenDevice device)'(1584), 'void removeMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'(1586), 및 'void removeScreenContextListener(MultiScreenContextListener listener)'(1588) 중 적어도 하나를 포함한다.
'getScreenType()' 메소드(1576)는 'int getScreenType()'로 선언되며, 해당 'HScreen'의 타입을 획득한다. 'getScreenType()' 메소드(1576)는 'SCREEN_TYPE_DISPLAY' 또는 'SCREEN_TYPE_LOGICAL'을 나타내는 정수를 반환한다.
'getScreenType()' 메소드(1576)는 MSM I01 버전으로부터 적용된다.
'getID()' 메소드(1564)는 'java.lang.String getID()'로 선언되며, 해상 스크린을 나타내는 기저 스크린 리소스들을 위한 플랫폼에 의존적인 고유 식별자를 획득한다. 여기서 고유성의 범위는 현재 활성 플랫폼별 멀티스크린 설정 및 모든 활성 디스플레이별 멀티스크린 설정과 연관된 스크린들보다 작지 않다. 스크린 식별자의 고유성의 범위가 다른 비활성화된 멀티스크린 설정들을 포함하는지 아닌지 여부는 플랫폼에 의존적이다.
스크린 식별자는 'getScreenCategory()'(1574)에 의해 반환되는 어떤 스크린 카테고리와도 동일해서는 안 된다.
S1 및 S2이 고유성의 구현된 범위의 컨텍스트 상의 'HScreen'의 인스턴스들이고 'MultiScreenManager.sameResources(S1,S2)'가 '거짓' 값을 반환한다면, '((MultiScreenContext)S1).getID()' 및 '((MultiScreenContext)S2).getID()'는 동일한 스트링을 반환해서는 안 된다. 반대로 'MultiScreenManager.sameResources(S1,S2)'가 '참' 값을 반환한다면, '((MultiScreenContext)S1).getID()' 및 '((MultiScreenContext)S2).getID()'는 동일한 스트링을 반환하여야 한다.
'getID()' 메소드(1564)는, 고유성의 구현된 범위 내에서 기술되는 해당 'HScreen' 인스턴스의 기저 리소스들을 나타내는 스트링 값을 반환한다.
'getID()' 메소드(1564)는 MSM I01 버전으로부터 적용된다.
'getScreenCategory()' 메소드(1574)는 'java.lang.String getScreenCategory()'로 선언되며, 해당 'HScreen' 인스턴스의 스크린 카테고리를 획득한다. 'getScreenCategory()' 메소드(1574)는 (ⅰ) 'MultiScreenConfiguration' 인터페이스에 의해 정의되는 상수들, 즉 'SCREEN_CATEGORY_DISPLAY'(1402), 'SCREEN_CATEGORY_MAIN'(1406), 'SCREEN_CATEGORY_PIP'(1412), 'SCREEN_CATEGORY_POP'(1414), 'SCREEN_CATEGORY_OVERLAY'(1410), 'SCREEN_CATEGORY_GENERAL'(1404) 중 하나 또는 (ⅱ) 플랫폼에 의존적인 스크린 카테고리를 나타내고, 접두어 "x-"로 시작되는 스트링 값, 중 어느 하나일 수 있다.
'getScreenCategory()' 메소드(1574)는 MSM I01 버전으로부터 적용된다.
'getVisible()' 메소드(1580)는 'boolean getVisible()'로 선언되며, 스크린 가시성을 획득한다.
'getVisible()' 메소드(1580)는 해당 'HScreen'이 일부 디스플레이 'HScreen' 상에서의 재생을 위해 가시성이 있다고 표시되는지 여부를 결정하며, 여기서 "가시성이 있다"는 용어는 'VideoOutputPort'의 활성화 또는 비활성 여부와 상관없이 'VideoOutputPort'에 래스터 신호를 출력한다고 정의된다. 디스플레이 'HScreen'은 가시성이 있다고 표시된 상태여야 한다. 로지컬 'HScreen'은 가시성이 있거나 숨겨질 수도, 즉 가시성이 없어질 수도 있다.
'getVisible()' 메소드(1580)는, 해당 'HScreen'이 일부 디스플레이 'HScreen'에서 가시성이 있거나 없다고 표시되는지 여부를 나타내는 불리언(boolean) 값을 반환한다.
'getVisible()' 메소드(1580)는 MSM I01 버전으로부터 적용된다.
'getZOrder()' 메소드(1582)는 'int getZOrder()'로 선언되며, 스크린 'z-order'를 획득한다. 즉, 해당 'HScreen'의 'z-order'를 결정한다. 디스플레이 'HScreen'은 항상 0인 'z-order'를 반환한다. 로지컬 'HScreen'이 디스플레이 'HScreen'에 연관된다면, 0 또는 그 이상의 'z-order'가 지정되어야 한다. 로지컬 'HScreen'이 디스플레이 'HScreen'에 연관되지 않는다면, 그 'z-order'는 '-1' 값이다. 'z-order'가 크면 클수록, 'HScreen' 인스턴스들 중 더 앞선 순서를 의미한다.
'getZOrder()' 메소드(1582)는 해당 'HScreen'의 'z-order' 또는 '-1' 값을 나타내는 값이다. 해당 'HScreen'이 디스플레이 'HScreen'에 연관되지 않은 로지컬 'HScreen'이라면, 'getZOrder()' 메소드(1582)는 '-1' 값을 반환하여야 한다.
'getZOrder()' 메소드(1582)는 MSM I01 버전으로부터 적용된다.
'getZOrder(HScreenDevice)'(1584)는 'int getZOrder(org.havi.ui.HScreenDevice device)'로 선언되며, 해당 스크린 내의 스크린 디바이스의 'z-order'를 획득한다. 즉, 후술되는 제한 요건을 만족하는 'HScreen'의 지정된 'HScreenDevice'의 'z-order'를 결정한다.
- 'HBackgroundDevice'이 해당 스크린 상에 존재하면, 가장 뒤쪽(바닥 쪽)의 'HBackgroundDevice'의 'z-order'는 0이다;
- 'HBackgroundDevice'이 해당 스크린 상에 존재하지 않고, 'HVideoDevice'가 해당 스크린 상에 존재하면, 가장 뒤쪽(바닥 쪽)의 'HVideoDevice'의 'z-order' 는 0이다.
- 'HBackgroundDevice' 및 'HVideoDevice'가 해당 스크린 상에 전혀 없고, 'HGraphicsDevice'가 스크린 상에 존재한다면, 가장 뒤쪽(바닥 쪽)의 'HGraphicsDevice'의 'z-order'는 0이다.
- 'HVideoDevice'의 'z-order'는 스크린 상의 어떤 'HBackgroundDevice'의 'z-order'보다 크다.
- 'HGraphicsDevice'의 'z-order'는 스크린 상의 어떤 'HVideoDevice'의 'z-order'보다 크다.
'z-order'가 클수록 'HScreen' 인스턴스 내의 'HScreenDevice' 인스턴스들 중 더 앞쪽(윗쪽) 순서를 나타낸다.
'HScreen' 인스턴스로 표현되는 기저 스크린 디바이스들의 각각 별개의 기저 스크린 디바이스는 별개의 'z-ordering'을 구성한다. 즉, 별개의 기저 스크린들을 나타내는 복수 개의 'HScreen' 인스턴스들이 주어진다면, 상기 스크린들의 기저 스크린 디바이스 리소스들에 지정된 'z-order' 값들은 동일한 'z-order' 인덱스들을 재사용할 수 있다.
'device' 파라미터는 해당 스크린과 연관된 'HScreenDevice'이다.
'getZOrder(HScreenDevice)' 메소드(1584)는 'HScreenDevice'의 'z-order'를 나타내는 음이 아닌 수를 반환한다.
'device'가 해당 스크린의 'HScreenDevice'가 아니라면, 'getZOrder(HScreenDevice)' 메소드(1584)는 'java.lang.IllegalArgumentException'를 발생시킨다.
'getZOrder(HScreenDevice)'(1584)는 MSM I01 버전으로부터 적용된다.
'getAudioSources()' 메소드(1558)는 'org.havi.ui.HScreenDevice[] getAudioSources()'로 선언되며, 해당 스크린의 오디오 소스들을 획득한다. 즉, 그 재생된 오디오가 해당 스크린에서의 오디오 재생을 위해 선택된 (또는 선택되고 믹싱된) 'HScreenDevice'들이 획득된다.
스크린의 디폴트 오디오 소스들은 상기 스크린과 연관된 모든 'HScreenDevice' 인스턴스들로 구성된다.
'getAudioSources()' 메소드(1558)에 의해 반환된 어레이의 엔트리의 순서는 본 명세서에서 정의되지 않으며, 플랫폼에 의존적으로 결정되는 것으로 간주되어야 한다.
'getAudioSources()' 메소드(1558)는, 'HScreenDevice' 인스턴스들의 (빈 어레이일 수도 있는 ) 어레이에 대한 참조를 반환한다. 여기서 각각의 인스턴스는 해당 스크린으로부터 믹싱된 오디오 재생에 관여한다. 반면에 해당 스크린이 믹싱된 오디오를 지원하지 않으면, 많아야 하나의 엔트리만이 반환된 어레이에 존재할 것이다.
'getAudioSources()' 메소드(1558)는 MSM I01 버전으로부터 적용된다.
'getAudioFocus()' 메소드(1556)는 'org.havi.ui.HScreen getAudioFocus()'로 선언되며, 오디오 포커스 스크린을 획득한다.
해당 'HScreen'의 오디오 포커스 스크린은 후술되는 규칙의 순서대로 따라 결정된다. 여기서 적용된 첫 번째 규칙이 만족된다면 다른 규칙들은 무시된다.
1. 해당 'HScreen'이 로지컬 스크린이라면, 이하의 하위 규칙들이 순서대로 준수된다.
a. 상기 로지컬 'HScreen'이 디스플레이 스크린에 맵핑된다면, 이하의 하위 규칙들이 적용된다.
ⅰ. 상기 로지컬 'HScreen'이 상기 디스플레이 스크린에 대해 현재 지정된 오디오 포커스라면, 상기 로지컬 'HScreen'이 반환된다.
ⅱ. 그렇지 않으면(상기 디스플레이 스크린의 오디오 스크린에 현재 지정되지 않았다면), 'null' 값이 반환된다.
b. 그렇지 않으면(디스플레이 스크린에 맵핑되지 않는다면), 상기 로지컬 'HScreen'은 비디오 출력 포트에 직접 맵핑되면, 해당 'HScreen'이 반환된다.
c. 그렇지 않으면(디스플레이 스크린에 맵핑되지 않고 비디오 출력 포트에 직접 맵핑되지 않는다면), 'null' 값이 반환된다.
2. 그렇지 않으면(해당 'HScreen'이 디스플레이 스크린이라면), 이하의 하위 규칙들이 준수된다.
a. 해당 디스플레이 스크린에 맵핑된 일부 로지컬 스크린로 오디오 포커스이 지정된다면, 로지컬 'HScreen'이 반환된다.
b. 그렇지 않으면(어떤 로지컬 스크린도 해당 디스플레이 스크린에 맵핑되지 않거나 해당 디스플레이 스크린에 맵핑된 어떤 로지컬 스크린도 오디오 포커스로 지정되지 않는다면), 해당 디스플레이 'HScreen'이 반환되지 않는다.
디스플레이 스크린의 오디오 포커스 스크린은, 맵핑된 모든 비디오 출력 포트들의 모든 (내재된) 오디오 재생 디바이스들에서 그 현재 선택된 오디오 소스들이 디스플레이 스크린이 재생되도록 지정된 스크린이다.
'getAudioFocus()' 메소드(1556)는 전술된 대로 'HScreen' 인스턴스나 'null' 값을 반환한다.
'getAudioFocus()' 메소드(1556)는 MSM I01 버전으로부터 적용된다.
'getOutputPorts()' 메소드(1572)는 'org.ocap.hardware.VideoOutputPort[] getOutputPorts()'로 선언되며, 스크린이 맵핑된 비디오 포트들을 획득한다. 즉, 'getOutputPorts()' 메소드(1572)에 의해 해당 'HScreen'과 연관된 'VideoOutputPort'들이 획득된다. 해당 'HScreen'의 타입이 'SCREEN_TYPE_DISPLAY'이라면, 해당 디스플레이 스크린과 연관된 'VideoOutputPort' 인스턴스들은 반환되어야 한다. 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이고 'HScreen'이 디스플레이 'HScreen'과 연관된다면, 상기 디스플레이 'HScreen'과 연관된 'VideoOutputPort' 인스턴스들이 반환되어야 한다. 해당 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이고 해당 'HScreen'이 디스플레이 'HScreen'과 연관되지 않으면, 빈 어레이가 반환되어야 한다.
'getOutputPorts()' 메소드(1572)는 'VideoOutputPort' 인스턴스들의 어레이에 대한 참조를 반환한다. 반환된 어레이가 빈 어레이라면, 해당 'HScreen'은 어떤 'VideoOutputPort'과도 연관되지 않는다.
'getOutputPorts()' 메소드(1572)는 MSM I01 버전으로부터 적용된다.
'getDisplayScreen()' 메소드(1562)는 'org.havi.ui.HScreen getDisplayScreen()'로 선언되며, 해당 스크린과 연관된 디스플레이 스크린을 획득한다. 즉, 'getDisplayScreen()' 메소드(1562)는 해당 'HScreen'과 연관된 디스플레이 'HScreen'을 획득한다.
상기 'HScreen'의 타입이 'SCREEN_TYPE_DISPLAY'라면, 상기 'HScreen'에 대한 참조가 반환되어야 한다. 상기 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이고 상기 'HScreen'이 디스플레이 'HScreen'과 연관된다면, 상기 디스플레이 'HScreen'이 반환되어야 한다. 상기 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이고, 상기 'HScreen'이 디스플레이 'HScreen'에 연관되지 않는다면, 'null' 값이 반환되어야 한다.
'getDisplayScreen()' 메소드(1562)는 디스플레이 'HScreen'에 대한 참조 또는 'null' 값을 반환한다. 'null' 값이라면, 상기 'HScreen'은 디스플레이 'HScreen'에 연관되지 않는다.
'getDisplayScreen()' 메소드(1562)는 MSM I01 버전으로부터 적용된다.
'getDisplayArea()' 메소드(1560)는 'org.havi.ui.HScreenRectangle getDisplayArea()'로 선언되며, 상기 스크린이 맵핑된 디스플레이 스크린의 영역을 획득한다. 즉, 'getDisplayArea()' 메소드(1560)는 해당 'HScreen'의 영역(범위)를 획득한다. 해당 'HScreen'의 타입은 'SCREEN_TYPE_DISPLAY'이라면, 그 값이 'HScreenRectangle(0,0,1,1)'과 동일한 'HScreenRectangle'이 반환되어야 한다. 해당 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이고 해당 'HScreen'이 디스플레이 'HScreen'에 연관되었다면, 상기 로지컬 'HScreen'과 연관된 디스플레이 'HScreen' 상에 상기 로지컬 'HScreen'에 의해 채워지는 영역(범위)이 반환되어야 한다. 상기 'HScreen'의 타입이 'SCREEN_TYPE_LOGICAL'이고 해당 'HScreen'이 디스플레이 'HScreen'과 연관되지 않는다면, 'null' 값이 반환되어야 한다.
'getDisplayArea()' 메소드(1560)는 'HScreenRectangle' 인스턴스에 대한 참조 또는 'null' 값을 반환한다. 'null' 값이라면 상기 'HScreen'은 디스플레이 'HScreen'과 연관되지 않는다.
'getDisplayArea()' 메소드(1560)는 MSM I01 버전으로부터 적용된다.
'getServiceContexts()' 메소드(1578)는 'javax.tv.service.selection.ServiceContext[] getServiceContexts()'로 선언되며, 상기 스크린과 연관된 서비스 컨텍스트들을 획득한다. 즉, 호출 어플리케이션의 억세스가 허용된 해당 'HScreen'에 연관된 'ServiceContext'들을 획득한다.
'getServiceContexts()' 메소드(1578)는 'ServiceContext' 인스턴스들의 어레이에 대한 참조를 반환한다. 반환된 어레이가 빈 어레이라면, 해당 'HScreen'은 어느 억세스 가능한 'ServiceContext'과도 연관되지 않는다.
'getServiceContexts()' 메소드(1578)는 MSM I01 버전으로부터 적용된다.
'addScreenContextListener(MultiScreenContextListener)' 메소드(1554)는 'void addScreenContextListener(MultiScreenContextListener listener)'로 선언되며, 스크린 컨텍스트 리스너를 부가한다. 즉, 'addScreenContextListener(MultiScreenContextListener)' 메소드(1554)는 스크린 컨텍스트 이벤트가 발생할 때 통지받을 리스너를 부가한다. 리스너가 이전에 부가되었고 이후 제거되지 않는다면, 리스너를 다시 부가하려는 시도는 어떠한 결과도 보여서는 안 된다.
'listener 파라미터는 MultiScreenContextListener' 인스턴스이다.
'addScreenContextListener(MultiScreenContextListener)' 메소드(1554)는 MSM I01 버전으로부터 적용된다.
'removeScreenContextListener(MultiScreenContextListener)' 메소드(1588)는 'void removeScreenContextListener(MultiScreenContextListener listener)'로 선언되며, 스크린 컨텍스트 리스너를 제거한다. 즉, 'removeScreenContextListener(MultiScreenContextListener)' 메소드(1588)는 스크린 컨텍스트 이벤트가 발생된 때 통지받기 위해 이전에 부가된 리스너를 제거한다. 현재 리스너가 현재 리스너로 등록되지 않았다면, 현재 리스너를 제거하려는 시도는 어떠한 결과도 보여서는 안 된다.
'listener' 파라미터는 'MultiScreenContextListener' 인스턴스이다.
'removeScreenContextListener(MultiScreenContextListener)' 메소드(1588)는 MSM I01 버전으로부터 적용된다.
'addMultiScreenConfigurationListener(MultiScreenConfigurationListener)' 메소드(1552)는 'void
addMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'로 선언되며, 해당 스크린이 디스플레이 스크린인 경우 해당 스크린에 적용되는 멀티스크린 설정 이벤트가 발생할 때 통지 받기 위한 리스너를 부가한다. 리스너가 이전에 부가되었고 이후 제거되지 않았다면, 리스너를 다시 부가하려는 시도는 어떠한 결과도 보여서는 안 된다.
디스플레이 스크린에 적용되는 설정 이벤트들은 상기 디스플레이 스크린과 연관된 로지컬 스크린들의 완료에 영향을 미치는 설정 이벤트들이어야 한다.
'MultiScreenConfigurationEvent'에 의해 정의되는 이벤트가 발생된다면, 이에 따라 MSM 구현이 각각의 등록된 스크린 설정 리스너에 통지하여야 한다.
'listener' 파라미터는 'MultiScreenConfigurationListener' 인스턴스이다.
상기 스크린의 타입이 'SCREEN_TYPE_DISPLAY'가 아니라면, 'addMultiScreenConfigurationListener(MultiScreenConfigurationListener)' 메소드(1552)는 'java.lang.IllegalStateException'를 발생시킨다.
'addMultiScreenConfigurationListener(MultiScreenConfigurationListener)' 메소드(1552)는 MSM I01 버전으로부터 적용된다.
'removeMultiScreenConfigurationListener(MultiScreenConfigurationListener)' 메소드(1586)는 'void removeMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'로 선언되며, 멀티스크린 설정 이벤트가 발생할 때 통지받기 위해 이전 부가된 리스너를 제거한다. 지정된 리스너가 리스너로 현재 등록되지 않았다면, 리스너를 제거하려는 시도는 어떠한 결과도 보여서는 안 된다.
'listener' 파라미터는 'MultiScreenConfigurationListener' 인스턴스이다.
'removeMultiScreenConfigurationListener(MultiScreenConfigurationListener)' 메소드(1586)는 MSM I01 버전으로부터 적용된다.
'getMultiScreenConfigurations()' 메소드(1568)는 'MultiScreenConfiguration[] getMultiScreenConfigurations()'로 선언되며, 멀티스크린 설정의 설정 타입이 'SCREEN_CONFIGURATION_DISPLAY'(1416)여서는 안 되는 디스플레이 스크린과 현재 연관된 모든 디스플레이별 멀티스크린 설정들을 획득한다.
'getMultiScreenConfigurations()' 메소드(1568)는 'MultiScreenConfiguration' 인스턴스들의 비지 않은 어레이를 반환한다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면 'getMultiScreenConfigurations()' 메소드(1568)는 'java.lang.SecurityException'를 발생시킨다.
'getMultiScreenConfigurations()' 메소드(1568)는 MSM I01 버전으로부터 적용된다.
'getMultiScreenConfigurations(String)' 메소드(1570)는 'MultiScreenConfiguration[] getMultiScreenConfigurations(java.lang.String screenConfigurationType)'로 선언되며, 디스플레이 스크린과 연관된 소정 타입의 디스플레이별 멀티스크린 설정들을 획득한다.
'screenConfigurationType' 파라미터는, (ⅰ) 'MultiScreenConfiguration' 인터페이스에 의해 정의되는 상수들의 목록, 즉 'SCREEN_CONFIGURATION_NON_PIP'(1420), 'SCREEN_CONFIGURATION_PIP'(1422), 'SCREEN_CONFIGURATION_POP'(1424), 'SCREEN_CONFIGURATION_GENERAL'(1418) 중 하나, 또는 (ⅱ) 멀티스크린 설정 타입으로 미리 정의되지 않은 일부 다른 플랫폼에 의존적인 값 중 적어도 하나이다.
'getMultiScreenConfigurations(String)' 메소드(1570)는, 지정된 설정 타입이 지원되는지 여부에 따라 'MultiScreenConfiguration' 인스턴스들의 어레이 또는 'null' 값을 반환한다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'getMultiScreenConfigurations(String)' 메소드(1570)는 'java.lang.SecurityException'를 발생시킨다.
'screenConfigurationType'가 'SCREEN_CONFIGURATION_DISPLAY'이거나, 스크린 설정 타입이 정의되지 않거나, 또는 플랫폼에 의존적이므로 스크린 설정 타입을 알 수 없다면, 'getMultiScreenConfigurations(String)' 메소드(1570)는 'java.lang.IllegalArgumentException'를 발생시킨다.
'getMultiScreenConfigurations(String)' 메소드(1570)는 MSM I01 버전으로부터 적용된다.
'getMultiScreenConfiguration()' 메소드(1566)는 'MultiScreenConfiguration getMultiScreenConfiguration()'로 선언되며, 해당 디스플레이 스크린을 위한 현재 활성 디스플레이별 멀티스크린 설정을 획득한다.
'getMultiScreenConfiguration()' 메소드(1566)는, 해당 디스플레이 스크린에 적용되는 현재 활성 디스플레이별 'MultiScreenConfiguration' 인스턴스를 반환한다.
'HScreen'이 디스플레이 스크린이 아니라면, 'getMultiScreenConfiguration()' 메소드(1566)는 'java.lang.IllegalStateException'를 발생시킨다.
'getMultiScreenConfiguration()' 메소드(1566)는 MSM I01 버전으로부터 적용된다.
도 16a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenManager' 클래스의 정의를 도시한다.
'org.ocap.ui' 패키지의 'MultiScreenManager' 클래스(1260)는 'java.lang.Object'의 하위 클래스이며, 모든 구현된 인터페이스들(All Implemented Interfaces)은 'org.davic.resources.ResourceServer'를 포함한다.
'org.ocap.ui의 MultiScreenManager' 클래스(1260)는 'public abstract class MultiScreenManager'로 선언되며, 'extends java.lang.Object'로 확장되고, 'implements org.davic.resources.ResourceServer'로 구현된다.
'MultiScreenManager' 클래스(1260)는 멀티스크린 매니지먼트 서비스들을 제공하는 OCAP 호스트 플랫폼에 의해 구현되는 추상적인 싱글턴 매니지먼트 클래스이다.
적용되는 다른 시맨틱 제한 조건 및 동작들은 본 명세서에서 상술된다.
'org.ocap.ui'의 'MultiScreenManager' 클래스(1260)는 MSM I01 버전으로부터 적용된다.
도 16b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenManager' 클래스의 생성자를 도시한다.
'MultiScreenManager' 클래스의 생성자(constructor)(1600)는 'protected MultiScreenManager()'로 선언되며, 보호된 디폴트 생성자이다.
'MultiScreenManager()'(1602)는 MSM I01 버전으로부터 적용된다.
도 16c 내지 16f 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenManager' 클래스의 메소드를 도시한다.
'org.ocap.ui'의 'MultiScreenManager' 클래스(1260)의 메소드(1630)는, 'void addMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'(1632), 'void addPlayerScreenDevices(javax.media.Player player, org.havi.ui.HScreenDevice[] devices)'(1634), 'void addResourceStatusListener(org.davic.resources.ResourceStatusListener listener)'(1636), 'org.havi.ui.HScreen[] findScreens(javax.tv.service.selection.ServiceContext context)'(1638), 'org.havi.ui.HScreen[] getCompatibleScreens(org.ocap.hardware.VideoOutputPort port)'(1640), 'org.havi.ui.HScreen getDefaultScreen()'(1642), 'org.havi.ui.HScreen getEmptyScreen()'(1644), 'static MultiScreenManager getInstance()'(1646), 'MultiScreenConfiguration getMultiScreenConfiguration()'(1648), 'MultiScreenConfiguration getMultiScreenConfiguration(org.havi.ui.HScreen screen)'(1650), 'MultiScreenConfiguration[] getMultiScreenConfigurations()'(1652), 'MultiScreenConfiguration[] getMultiScreenConfigurations(java.lang.String screenConfigurationType)'(1654), 'org.havi.ui.HScreen getOutputPortScreen(org.ocap.hardware.VideoOutputPort port)'(1656), 'org.havi.ui.HScreenDevice[] getPlayerScreenDevices(javax.media.Player player)'(1658), 'org.havi.ui.HScreen[] getScreens()'(1660), 'boolean isEmptyScreen(org.havi.ui.HScreen screen)'(1662), 'boolean isEmptyScreenDevice(org.havi.ui.HScreenDevice device)'(1664), 'void moveServiceContexts(org.havi.ui.HScreen src, org.havi.ui.HScreen dst, javax.tv.service.selection.ServiceContext[] contexts)'(1666), 'void removeMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'(1668), 'void removePlayerScreenDevices(javax.media.Player player, org.havi.ui.HScreenDevice[] devices)'(1670), 'void removeResourceStatusListener(org.davic.resources.ResourceStatusListener listener)'(1672), 'void requestMultiScreenConfigurationChange(MultiScreenConfiguration configuration, java.util.Dictionary serviceContextAssociations)'(1674), 'boolean sameResources(org.havi.ui.HScreenDevice device1, org.havi.ui.HScreenDevice device2)'(1676), 'boolean sameResources(org.havi.ui.HScreen screen1, org.havi.ui.HScreen screen2)'(1678), 'boolean sameResources(javax.tv.service.selection.ServiceContext sc1, javax.tv.service.selection.ServiceContext sc2)'(1680), 'void setMultiScreenConfiguration(MultiScreenConfiguration configuration, java.util.Dictionary serviceContextAssociations)'(1682), 및 'void swapServiceContexts(org.havi.ui.HScreen screen1, org.havi.ui.HScreen screen2, javax.tv.service.selection.ServiceContext[] exclusions)'(1684) 중 적어도 하나를 포함한다.
'java.lang.Object' 클래스로부터 상속된 메소드들(1690)은 'clone', 'equals', 'finalize', 'getClass', 'hashCode', 'notify', 'notifyAll', 'toString', 'wait', 'wait', 'wait' 중 적어도 하나를 포함한다.
'org.davic.resources.ResourceServer' 인터페이스로부터 상속된 메소드들(1695)은 'addResourceStatusEventListener', 'removeResourceStatusEventListener' 중 적어도 하나를 포함한다.
'getScreens()' 메소드(1660)는 'public org.havi.ui.HScreen[] getScreens()'로 선언되며, 억세스 가능한 'HScreen' 인스턴스들을 획득한다.
반환된 'HScreen' 인스턴스들은 후술되는 대로 결정되어야 한다. 'HScreen' 인스턴스가 'MonitorAppPermission("multiscreen.configuration")'가 허용된 OCAP 어플리케이션에 의해 호출된 때, 'HScreen' 인스턴스는, 'getScreens()' 메소드(1660)가 호출된 시점에 억세스 가능한 'MultiScreenConfiguration' 인스턴스를 통해 접하는 각각의 디스플레이 스크린 및 각각의 로지컬 스크린를 위해 반환되어야 한다. 그렇지 않으면, 'HScreen' 인스턴스는, 재생되기 위해서 또는 재생 가능성이 있기 위해, 억세스 가능한 'ServiceContext'가 직/간접적으로 연관된 각각의 디스플레이 스크린 및 각각의 로지컬 스크린을 위해 반환되어야 한다.
반환된 'HScreen[]' 어레이 중 첫 번째 'HScreen' 인스턴스는 'MultiScreenManager' 클래스의 'getDefaultScreen()' 메소드(1642)에 의해 반환된 값과 동일하여야 한다. 반환된 어레이의 다음 인자들은 미리 정해진 순서를 따르지는 않으며, 어플리케이션은 상기 다음 인자들의 순서에 의존해서는 안 된다.
'getScreens()' 메소드(1660)에 의해 반환되는 'HScreen' 인스턴스들은, 스크린이 억세스 가능한 멀티스크린 설정에 부가되거나 억세스 가능한 멀티스크린 설정으로부터 제거될 때처럼, 어플리케이션의 라이프사이클 동안 변한다. 그러나, 어플리케이션의 디폴트 'HScreen'을 나타내는 'HScreen' 인스턴스 참조는 어플리케이션의 라이프사이클 동안 고정되어 있으면 안 된다. 즉, 주어진 어플리케이션 인스턴스 측면에서 볼 때, MSM 구현은 항상 'HScreen' 인스턴스들의 반환된 어레이의 첫 번째 인자와 동일한 'HScreen' 인스턴스 참조를 반환하여야 한다.
'getScreens()' 메소드(1660)가 값을 반환하는 시점과 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 또는 'MultiScreenContextEvent.MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED' 이벤트가 발생되거나 상기 이벤트가 신호 출력되는 시점 사이의 기간 동안, 'getScreens()' 메소드(1660)에 의해 반환되는 'HScreen' 인스턴스는 빈 'HScreen'과 동일해서는 안 된다.
'getScreens()' 메소드(1660)에 의해 반환되는 각각의 'HScreen' 인스턴스는, 어플리케이션 라이프사이클 동안 'getHBackgroundDevices()', 'getHVideoDevices()', 및 'getHGraphicsDevices()' 메소드들로부터 반환된 'HScreenDevice' 인스턴스들과는 다른 'HScreenDevice' 인스턴스들을 반환할 수 있다. 그러나, 'getDefaultScreen()' 메소드의 정의 하에서 후술되는 대로, 'getHBackgroundDevices()' 메소드, 'getHVideoDevices()' 메소드, 및 'getHGraphicsDevices()' 메소드를 통해 디폴트 'HScreen' 인스턴스들로부터 반환된 디폴트 'HBackgroundDevice', 'HVideoDevice', 및 'HGraphicsDevice' 인스턴스들은 어플리케이션 라이프사이클 동안 고정되어야 한다. 반면에, 이러한 디폴트 'HScreenDevice' 인스턴스들의 기저 디바이스 리소스들 및 설정들은 변할 수 있다.
'getScreens()' 메소드(1660)가 값을 반환하는 시점과 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 또는 'MultiScreenContextEvent.MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED' 이벤트가 발생하는 시점 사이의 기간 동안, 'getScreens()' 메소드(1660)에 의해 반환된 'HScreen'의 백그라운드, 비디오 또는 그래픽 스크린 디바이스, 즉 'HBackgroundDevice', 'HVideoDevice', 또는 'HGraphicsDevice'는 특정한 서브타입의 빈 'HScreenDevice'와 동일해서는 안 된다.
'getScreens()' 메소드(1660)에 의해 반환되는 'HScreen' 인스턴스의 'getHBackgroundDevices()' 메소드, 'getHVideoDevices()' 메소드, 및 'getHGraphicsDevices()' 메소드로부터 반환되는 'HScreenDevice' 인스턴스들의 개수는 'HScreen' 인스턴스의 라이프사이클 동안 변할 수 있다. 만약 상기 개수가 변한다면, 'MultiScreenContextEvent.MULTI_SCREEN_CONTEXT_DEVICES_CHANGED' 이벤트가 발생되고 모든 등록된 'MultiScreenContextListener' 인스턴스들에게 전달되어야 한다.
특정 타입의 'HScreenDevice' 인스턴스들의 개수가 (주어진 'HScreen' 인스턴스에 대해) 증가하거나 동일하게 유지된다면, 이전에 어플리케이션에 반환된 넌-디폴트 'HScreenDevice' 인스턴스에 대한 참조는 실행가능한 상태로 유지되어야 하고, MSM 구현의 선택시, (ⅰ) 스크린 디바이스의 타입의 새로운 기저 디바이스 리소스들을 나타내기 위해 재사용되거나, 또는 (ⅱ) 상기 정의된 바와 같이 적합한 서브타입의 빈 'HScreenDevice'로 재설정되어야 한다. (ⅰ)의 경우, 재사용되는 'HScreenDevice' 인스턴스는, 그 스크린 디바이스 타입에 따라 'getHBackgroundDevices()' 메소드, 'getHVideoDevices()' 메소드, 또는 'getHGraphicsDevices()' 메소드로부터 반환되는 스크린 디바이스들 중에 존재하여야 한다. (ⅱ)의 경우, 그 상태가 빈 'HScreenDevice' 상태로 재설정된 'HScreenDevice' 인스턴스는 'getHBackgroundDevices()' 메소드, 'getHVideoDevices()' 메소드, 또는 'getHGraphicsDevices()' 메소드로부터 반환된 스크린 디바이스들 중에 존재해서는 안 된다.
특정 타입의 'HScreenDevice' 인스턴스들의 개수가 (주어진 'HScreen' 인스 턴스에 비해) 감소한다면, 해당 어플리케이션에 이전에 반환된 넌-디폴트 'HScreenDevice' 인스턴스에 대한 어떤 참조도 실행가능한 상태로 유지되어야 하고, 빈 스크린 디바이스 상태로 재설정되어야 하며, 'HScreen' 인스턴스에 의해 반환된 스크린 디바이스들 중에 존재해서는 안 된다.
상기 기술된 동작의 최종 효과는, 그 디폴트 'HScreen' 인스턴스들 및 디폴트 'HScreenDevice' 인스턴스들에만 억세스하는 어플리케이션이 MSM 기능성의 존재에 대한 인지 없이 상기 인스턴스들에 계속 억세스하고 사용할 수 있다는 점이다. 반면에, 넌-디폴트 'HScreen' 인스턴스들 또는 넌-디폴트 'HScreenDevice' 인스턴스들에 억세스하는 어플리케이션은, 넌-디폴트 스크린에 연관되는 스크린 디바이스들에 대한 변경 뿐만 아니라 현재 플랫폼별 멀티스크린 설정 및 디스플레이별 멀티스크린 설정에 대한 변경들을 감시할 필요가 있다.
멀티스크린 설정 변경의 결과로 어플리케이션에 의해 이전에 참조된 넌-디폴트 'HScreen' 인스턴스가 빈 스크린 상태로 재설정된다면, 어플리케이션은 적합한 'MultiScreenConfigurationEvent' 이벤트 이전에 획득되었던 'HScreen' 인스턴스 참조들와 상기 이벤트 이후에 획득될 수 있는 'HScreen' 인스턴스 참조들을 비교함으로써, 상기 재설정 사실을 검출할 수 있다. 상기 이벤트 이후에, 빈 상태로 재설정되었던 'HScreen' 인스턴스들은 'getScreens()' 메소드(1660)에 의해 반환된 'HScreen' 인스턴스들의 어레이에 더 이상 존재하지 않게 된다. 나아가, 이전에 획득된 'HScreen' 인스턴스들에 대해 'MultiScreenManager' 클래스에 의해 정의된 'isEmptyScreen(HScreen)' 메소드를 사용함으로써 재설정되었었는지 여부가 확인될 수 있다. 결국, 어플리케이션이 재설정된 'HScreen' 인스턴스를 계속 사용한다면, 그 동작은 충분히 정의되고 변경될 수 없다.
유사하게, 멀티스크린 설정 변화의 결과로 어플리케이션에 의해 이전에 참조된 넌-디폴트 'HScreenDevice' 인스턴스가 빈 스크린 디바이스 상태로 재설정된다면, 적합한 'MultiScreencontexEvent' 이벤트 이전에 획득되었던 'HScreenDevice' 인스턴스 참조들과 상기 이벤트 이후에 획득될 수 있는 'HScreenDevice' 인스턴스 참조들을 비교함으로써, 어플리케이션은 상기 재설정 사실을 검출할 수 있다. 상기 이벤트 이후, 빈 상태로 재설정되었던 'HScreenDevice' 인스턴스들은 'getScreens()' 메소드(1660)에 의해 억세스 가능한 'HScreen' 인스턴스들에 더 이상 억세스 가능하지 않게 된다. 나아가, 'MultiScreenManager' 클래스에 의해 정의된 'isEmptyScreenDevice(HScreenDevice)' 메소드를 통해, 이전에 획득된 'HScreenDevice' 인스턴스들이 재설정되었었는지 여부가 확인될 수 있다. 결국, 어플리케이션이 재설정된 'HScreenDevice' 인스턴스를 계속 사용한다면, 그 동작은 잘 정의되고 변경되지 않는다.
(예를 들어, 'HScreen' 인스턴스가 생성된 때 설정 가능하지 않고, MSM 구현이 소정 'HScreen' 인스턴스들에 대해 'MultiScreenConfigurableContext' 인터페이스를 선택적으로 구현하기 때문에) 'HScreen' 인스턴스, S,가 'MultiScreenConfigurableContext' 인터페이스를 구현하지 않고, 새로운 기저 스크린 리소스들이 설정 가능하다면(그리하여 상기 기저 스크린 리소스들을 나타내는 'HScreen' 인스턴스 상에서 'MultiScreenConfigurableContext' 인터페이스가 구현 된다면), MSM 구현은 멀티스크린 설정이 변경될 때 새로운 기저 스크린 리소스들을 나타내는 S를 재사용해서는 안되며, 대신 S를 빈 상태로 재설정하여야 한다.
'getScreens()' 메소드(1660)는 전술된 대로 'HScreen' 인스턴스들의 비지 않은 어레이를 반환한다.
'getScreens()' 메소드(1660)는 MSM I01 버전으로부터 적용된다.
'getDefaultScreen()' 메소드(1642)는 'public org.havi.ui.HScreen getDefaultScreen()'로 선언되며, 디폴트 'HScreen' 인스턴스를 획득한다.
'getDefaultScreen()' 메소드(1642)에 의해 반환된 'HScreen' 인스턴스는, 현재 활성화된 디폴트 기저 스크린 디바이스들 및 상기 현재 활성화된 디폴트 기저 스크린 디바이스들의 현재 활성 HAVi 스크린 설정들을 나타내야 한다. 또한, 상기 'HScreen' 인스턴스는, 현재 활성 넌-디폴트인 기저 스크린 디바이스들 및 상기 현재 활성 넌-디폴트인 기저 스크린 디바이스들의 설정들을 나타낼 수 있다.
반환된 디폴트 'HScreen' 인스턴스는, 호출 어플리케이션 또는 그 동작에 대해 'getDefaultScreen()' 메소드(1642)의 호출된 어플리케이션에 대해 '디폴트'라고 의도된다. 소정 어플리케이션을 내포하지 않는 컨텍스트 상의 플랫폼 구현에 의해 'getDefaultScreen()' 메소드(1642)가 호출된다면, 반환된 값은 정의되지 않고, 예를 들어 'null' 값을 반환하는 경우를 포함하여, 플랫폼에 의존적이어야 한다.
어플리케이션의 라이프사이클 동안, 'getDefaultScreen()' 메소드(1642)로부터 반환되는 참조는 고정되어야 한다. 더욱이, 이와 유사하게 상기 디폴트 'HScreen' 인스턴스의 'getDefaultHBackgroundDevice()' 메소드, 'getDefaultHVideoDevice()' 메소드, 및 'getDefaultHGraphicsDevice()' 메소드에 의해 반환되는 디폴트 'HScreenDevice' 인스턴스들은 어플리케이션의 라이프사이클 동안 고정되어야 한다. 이러한 참조값의 일관성에도 불구하고, 기저 디바이스 리소스들 및 기저 디바이스 리소스들의 기저 설정들은 어플리케이션의 라이프사이클 동안 변할 수 있다.
'getDefaultScreen()' 메소드(1642)가 값을 반환하는 시점과 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 또는 'MultiScreenContextEvent.MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED' 이벤트가 발생되는 시점 사이의 기간 동안, 'getDefaultScreen()' 메소드(1642)에 의해 반환된 어떤 'HScreen'의 넌-디폴트 백그라운드, 비디오, 또는 그래픽 스크린 디바이스, 즉 'HBackgroundDevice', 'HVideoDevice', 또는 'HGraphicsDevice'라도 소정 서브타입의 빈 'HScreenDevice'와 동일해서는 안 된다.
'getDefaultHBackgroundDevice()' 메소드, 'getDefaultHVideoDevice()' 메소드, 및 'getDefaultHGraphicsDevice()' 메소드에 의해 반환된 디폴트 'HScreenDevice' 인스턴스들 중 하나의 어떤 'HScreenConfiguration' 파라미터 (또는 유도된 스크린 디바이스 타입의 특정 파라미터)가 어플리케이션의 라이프사이클 동안 변한다면, 적합한 'HScreenConfigurationEvent' 이벤트가 생성되어야 하고, 모든 등록된 'HScreenConfigurationListener' 인스턴스들로 전달되어야 한다. 유사하게, 디폴트 'HScreen' 인스턴스에 의해 구현되는 'MultiScreenContext' 인터페이스의 'query'('get*') 메소드들에 의해서 어떠한 값이라도 반환된다면, 적합한 'MultiScreenContextEvent' 이벤트가 발생되고 모든 등록된 'MultiScreenContextListener' 인스턴스들로 전달되어야 한다.
'getDefaultScreen()' 메소드(1642)에 의해 반환된 어떠한 'HScreen' 인스턴스라도 'MultiScreenConfigurableContext' 인터페이스를 구현한다면, 반환된 어떠한 'HScreen' 인스턴스에 의해서 표현된 기저 스크린 리소스들이 설정 가능한지 아닌지 여부와 상관 없이 'getDefaultScreen()' 메소드(1642)에 의해 반환된 모든 'HScreen' 인스턴스는 'MultiScreenConfigurableContext' 인터페이스를 구현하여야 한다.
'getDefaultScreen()' 메소드(1642)는, 전술된 대로 'HScreen' 인스턴스를 반환한다.
'getDefaultScreen()' 메소드(1642)는 MSM I01 버전으로부터 적용된다.
'findScreens(ServiceContext)' 메소드(1638)는 'public org.havi.ui.HScreen[] findScreens(javax.tv.service.selection.ServiceContext context)'에 의해 선언되며, 소정 서비스 컨텍스트와 연관된 적어도 하나 이상의 억세스 가능한 스크린을 검색한다. 즉, 주어진 서비스 컨텍스트는 'HScreen' 인스턴스들과 연관되지 않거나, 하나 이상의 'HScreen' 인스턴스들과 연관될 수 있다. 즉, 'findScreens(ServiceContext)' 메소드(1638)는 지정된 'ServiceContext'가 연관된 억세스 가능한 'HScreen' 인스턴스들을 검색한다. ('getScreens()' 메소드(1660)가 'findScreens(ServiceContext)' 메소드(1638)가 호출된 시점에 동일한 어플리케이션에 의해 호출된 때) 'getScreens()' 메소드(1660)가 'HScreen' 인스턴스를 반환한다면(또는 반환할 것이라면) 'HScreen' 인스턴스는 (일부 어플리케이션에 의해) 억세스 가능하다.
'context' 파라미터는 'ServiceContext' 인스턴스이다.
'findScreens(ServiceContext)' 메소드(1638)는 'HScreen' 인스턴스들의 어레이 또는 'null' 값을 반환한다. 해당 'ServiceContext'가 일부 억세스 가능한 'HScreen'과 연관되었다면, 상기 'HScreen'은 'null' 값이 아니고 빈 어레이가 아니어야 하는 반환된 어레이 내에 존재하여야 한다. 그렇지 않으면, 'null' 값이 반환되며, 이는 'ServiceContext'는 어떤 'HScreen'과도 연관되지 않음을 나타낸다.
'findScreens(ServiceContext)' 메소드(1638)는 MSM I01 버전으로부터 적용된다.
'getOutputPortScreen(VideoOutputPort)' 메소드(1656)는 'public org.havi.ui.HScreen getOutputPortScreen(org.ocap.hardware.VideoOutputPort port)'로 선언되며, 출력 포트와 연관된 스크린을 획득한다. 즉, 소정 'VideoOutPutPort' 인스턴스가 주어진다면, 'getOutputPortScreen(VideoOutputPort)' 메소드(1656)는 재생을 위해 상기 출력 포트와 연관된 'Hscreen' 인스턴스를 획득한다.
'port' 파라미터는 'VideoOutputPort' 인스턴스이다.
'getOutputPortScreen(VideoOutputPort)' 메소드(1656)는 소정 출력 포트와 연관된 'HScreen' 인스턴스를 반환하거나, 아무런 연관관계가 없다면 'null' 값을 반환한다.
'getOutputPortScreen(VideoOutputPort)' 메소드(1656)는 MSM I01 버전으로부터 적용된다.
'getCompatibleScreens(VideoOutputPort)' 메소드(1640)는 'public org.havi.ui.HScreen[] getCompatibleScreens(org.ocap.hardware.VideoOutputPort port)'로 선언되며, 출력 포트와 호환성이 있는 억세스 가능한 스크린들을 획득한다.
소정 'VideoOutputPort' 인스턴스가 주어진다면, 'getCompatibleScreens(VideoOutputPort)' 메소드(1640)는, 재생을 위해 출력 포트와 연관될 수 있는 ('getScreens()' 메소드에 의해 반환된 더 많은 인스턴스들 중) 'HScreen' 인스턴스들의 하위 인스턴스들을 획득한다.
'port' 파라미터는 'VideoOutputPort' 인스턴스이다.
'getCompatibleScreens(VideoOutputPort)' 메소드(1640)는, 소정 출력 포트와 연관될 수 있는 'HScreen' 인스턴스들의 어레이를 반환한다. 반환되는 'HScreen' 어레이는 빈 어레이일 수도 있다.
'getCompatibleScreens(VideoOutputPort)' 메소드(1640)는 MSM I01 버전으로부터 적용된다.
'getMultiScreenConfigurations()' 메소드(1652)는 'public MultiScreenConfiguration[] getMultiScreenConfigurations()'로 선언되며, 멀티스크린 설정들의 설정 타입과 상관 없이 플랫폼에 의해 지원되는 모든 현재 멀티스크린 설정들을 획득한다.
'getMultiScreenConfigurations()' 메소드(1652)에 의해 반환되는 멀티스크린 설정 인스턴스들은 (디스플레이 스크린들로만 설정된) 모든 플랫폼별 멀티스크린 설정과 (단 하나의 디스플레이 스크린 및 하나 이상의 로지컬 스크린들로 설정된) 모든 디스플레이별 멀티스크린 설정들을 포함하여야 한다.
'getMultiScreenConfigurations()' 메소드(1652)에 의해 반환된 멀티스크린 설정들의 순서는 본 명세서에 의해 정의되지 않는다.
'getMultiScreenConfigurations()' 메소드(1652)는 'MultiScreenConfiguration' 인스턴스들의 어레이를 반환한다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'getMultiScreenConfigurations()' 메소드(1652)는 'java.lang.SecurityException'를 발생시켜야 한다.
'getMultiScreenConfigurations()' 메소드(1652)는 MSM I01 버전으로부터 적용된다.
'getMultiScreenConfigurations(String)' 메소드(1654)는 'public MultiScreenConfiguration[] getMultiScreenConfigurations(java.lang.String screenConfigurationType)'로 선언되며, 소정 설정 타입의 멀티스크린 설정들을 획득한다.
'screenConfigurationType' 파라미터는 (ⅰ) 'MultiScreenConfiguration'에 의해 정의된 상수들, 즉 'SCREEN_CONFIGURATION_DISPLAY'(1416), 'sCREEN_CONFIGURATION_NON_PIP'(1420), 'SCREEN_CONFIGURATION_PIP'(1422), 'SCREEN_CONFIGURATION_POP'(1424), 'SCREEN_CONFIGURATION_GENERAL'(1418) 중 하나, 또는 (ⅱ) 멀티스크린 설정 타입으로 미리 정의되지 않은 일부 다른 플랫폼에 의존적인 값, 중 하나인 파라미터이다.
'getMultiScreenConfigurations(String)' 메소드(1654)에 의해 반환되는 멀티스크린 설정 인스턴스들은, 'getMultiScreenConfigurations()' 메소드(1652)에 의해 반환되는 어레이 중에 나타나는 지정된 타입의 모든 멀티스크린 설정들을 포함하여야 한다.
'getMultiScreenConfigurations(String)' 메소드(1654)에 의해 반환되는 멀티스크린 설정들의 순서는 본 명세서에 의해 정의되지 않는다.
'getMultiScreenConfigurations(String)' 메소드(1654)는, 지정된 설정 타입이 지원되는지 아닌지 여부에 따라 'MultiScreenConfiguration' 인스턴스들의 어레이 또는 'null' 값을 반환한다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'getMultiScreenConfigurations(String)' 메소드(1654)는 'java.lang.SecurityException'를 발생시킨다.
'getMultiScreenConfigurations(String)' 메소드(1654)는 MSM I01 버전으로부터 적용된다.
'getMultiScreenConfiguration(HScreen)' 메소드(1650)는 'public MultiScreenConfiguration getMultiScreenConfiguration(org.havi.ui.HScreen screen)'로 선언되며, 소정 스크린의 멀티스크린 설정을 획득한다.
주어진 'HScreen' 인스턴스는 멀티스크린 설정 인스턴스와 연관되지 않거나, 단 하나의 멀티스크린 설정 인스턴스에만 연관되어야 한다. 그러나, 단일 기저 스크린은 복수 개의 'HScreen' 인스턴스들에 의해 잠재적으로 공유(복수로 참조)될 수 있으므로, 기저 스크린( 및 상기 기저 스크린의 리소스들)은 하나 이상의 멀티스크린 설정과 연관될 수 있다.
'screen' 파라미터는 'HScreen' 인스턴스이다.
'getMultiScreenConfiguration(HScreen)' 메소드(1650)는, 해당 'Hscreen'이 구성 스크린인 'MultiScreenConfiguration' 인스턴스를 반환하거나, 해당 'HScreen'이 고립되었다면(즉, 예를 들어 'HScreen'이 빈 스크린인 경우와 같이 멀티스크린 설정이 'HScreen'을 구비하지 않는다면), 'null' 값을 반환한다.
'getMultiScreenConfiguration(HScreen)' 메소드(1650)는 MSM I01 버전으로부터 적용된다.
'getMultiScreenConfiguration()' 메소드(1648)는 'public MultiScreenConfiguration getMultiScreenConfiguration()'로 선언되며, 현재 활성 플랫폼별 디스플레이 멀티스크린 설정을 획득한다.
'getMultiScreenConfiguration()' 메소드(1648)는 현재 활성 플랫폼별 디스플레이 'MultiScreenConfiguration' 인스턴스를 반환한다.
'getMultiScreenConfiguration()' 메소드(1648)는 MSM I01 버전으로부터 적용된다.
'setMultiScreenConfiguration()' 메소드(1682)는 'public void setMultiScreenConfiguration(MultiScreenConfiguration configuration, java.util.Dictionary serviceContextAssociations)'로 선언되며, 현재 활성 플랫폼별 디스플레이 멀티스크린 설정을 설정한다.
해당 'configuration'이 현재 플랫폼별 디스플레이 멀티스크린 설정이 아닌 경우, 'SecurityException'가 적용되지 않는다면, 'setMultiScreenConfiguration()' 메소드(1682)는 다른 부수적 작용 없이 값을 반환한다.
해당 'configuration'이 현재 플랫폼별 디스플레이 멀티스크린 설정이 아니고, 'SecurityException', 'IllegalArgumentException', 및 'IllegalStateException'가 적용되지 않는다면, 'setMultiScreenConfiguration()' 메소드(1682)는 OCAP 멀티스크린 매니저 익스텐션(OCAP Multiscreen Manager(MSM) Extension)에 대해 정의된 동기적인(synchronous) 플랫폼별 멀티스크린 설정 변경 처리를 수행한다.
'serviceContextAssociations' 인자가 특정된다면(즉, 'null' 값이 아니라면), 호출하는 어플리케이션에 억세스 가능한 어떤 'ServiceContext' 인스턴스라도 아무 스크린과 연관되지 않거나, 지정된 (새로운) 플랫폼별 멀티스크린 설정( 또는 그의 디스플레이별 멀티스크린 설정들) 상의 적용 가능한 스크린(들)과 연관되어야 한다. 일부 억세스 가능한 'ServiceContext'와의 연관 관계가 없거나, 일부 억세스 가능한 'ServiceContext' 인스턴스가 소정 연관 관계들 내에 존재하지 않거나, 상기 인스턴스가 존재하지만 그러한 적용 가능한 스크린이 새로운 플랫폼 별 멀티스크린 설정(또는 그 디스플레이별 멀티스크린 설정들) 상에 존재하지 않는다면, 'ServiceContext' 인스턴스는 해당 멀티스크린 설정의 디폴트 서비스 컨텍스트와 연관된 스크린, 즉 'configuration.getDefaultServiceContextScreen()'에 의해 반환되는 스크린,과 연관되어야 한다.
그 참조값들이 해당 'serviceContextAssociations' 딕셔너리에서 키(key)로 표현된 억세스 가능한 'ServiceContext' 인스턴스들을 일치시키기 위해, 상기 키(key)들에 대한 가상 메소드 'equals(Object')가 사용되어야 하며, 이 경우 'setMultiScreenConfiguration()' 메소드(1682)는 'Object.equals(Object)' 메소드의 디폴트 구현과 동일하게 행동한다고 가정된다.
주어진 어플리케이션 인스턴스의 컨텍스트에서, MSM 호스트 구현은 어플리케이션에 이용되는 'ServiceContext' 인스턴스들과 기저 서비스 컨텍스트 리소스들의 집합들 사이의 일대일 관계를 유지하여야 한다. MSM 호스트 구현이 상기 일대일 관계를 유지하는데 실패한다면, MSM 호스트 구현이 'serviceContextAssociations' 딕셔너리를 참조할 때, MSM 구현은 기저 서비스 컨텍스트 리소스들의 별개의 두 집합이 동일한 서비스 컨텍스트라고 간주할 수 있다. 예를 들어 다른 시점이라면 단일 'ServiceContext' 인스턴스가 리소스들의 별개의 기저 집합들을 참조한다. 또는, MSM 호스트 구현이 상기 일대일 관계를 유지하는데 실패한다면, MSM 호스트 구현이 'serviceContextAssociations' 딕셔너리를 참조할 때, MSM 구현은 기저 서비스 컨텍스트 리소스들의 단일 집합이 별개의 두 서비스 컨텍스트들이라고 간주할 수 있다. 예를 들어 주어진 시점에 별개의 두 'ServiceContext' 인스턴스가 리소스들의 동일한 기저 집합을 참조한다.
'setMultiScreenConfiguration()' 메소드(1682)에 의해 스크린들 사이에서 내재적으로 교체되거나 이동되는 서비스 컨텍스트와 연관된 비디오를 처리하기 위해 사용되고 있는 비디오 파이프라인의 디코더 포맷 변환(DFC) 설정요소의 상태는 'setMultiScreenConfiguration()' 메소드(1682)의 수행 여부에 의해 영향을 받지 않아야 한다.
'configuration' 파라미터는 현재 활성 플랫폼별 디스플레이 멀티스크린 설정이 되는 'MultiScreenConfiguration' 인스턴스이다.
'serviceContextAssociations' 파라미터는 'null' 값이 아니라면, 그 키들(keys)이 'ServiceContext' 인스턴스들이고 그 값들이 스트링 값인 'Dictionary' 인스턴스이고, 여기서 스트링 값들은 다음과 같이 정의된다: (ⅰ) 스트링 값이 "-"이라면, (부합하는 서비스 컨텍스트가 설정 변경 후의 어떤 스크린과도 연관되지 않는 경우,) 어떠한 스크린도 적용되지 않는다. (ⅱ) 그렇지 않으면, 스트링 값이 "*"이라면, 새로운 스크린 설정의 모든 스크린들이 적용된다. (ⅲ) 그렇지 않으면, 스트링 값이 'MultiScreenContext.getID()' 메소드에 의해 반환된 스크린 식별자라면, 그 스크린이 적용된다. (ⅳ) 그렇지 않으면, 스트링 값이 'MultiScreenContext.getScreenCategory()' 메소드에 의해 반환된 스크린 카테고리라면, 그 카테고리의 새로운 설정의 스크린이 적용된다. (ⅴ) 그렇지 않으면, 스트링 값이 스크린 식별자의 세미콜론으로 구분된 목록이라면, 부합하는 식별자의 새로운 설정의 각각의 스크린이 적용된다. (ⅵ) 그렇지 않으면, 스트링 값이 스크린 카테고리들의 세미콜론으로 구분된 목록이라면, 부합하는 스크린 카테고리들의 새로운 설정의 각각의 스크린이 적용된다. (ⅶ) 그러지 않으면, 스크링 값이 스크린 식별자들 또는 스크린 카테고리들의 세미콜론으로 구분된 목록이라면, 부합하는 식별자 또는 카테고리의 새로운 설정의 각각의 스크린이 적용된다. (ⅷ) 그렇지 않으면 새로운 설정의 디폴트 서비스 컨텍스트의 연관된 스크린이 적용된다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않았다면, 'setMultiScreenConfiguration()' 메소드(1682)는 'java.lang.SecurityException'를 발생시킨다.
'configuration' 파라미터가 'MultiScreenManager.getMultiScreenConfigurations(SCREEN_CONFIGURATION_DISPLAY)'에 의해 반환되는 플랫폼별 멀티스크린 설정이 아니라면, 'setMultiScreenConfiguration()' 메소드(1682)는 'java.lang.IllegalArgumentException'를 발생시킨다.
MSM 구현이 (ⅰ) 지정된 멀티스크린 설정의 활성화를 허용하지 않거나, (ⅱ) 'setMultiScreenConfiguration()' 메소드(1682)가 이전에 호출되고 변경 처리 과정이 아직 완료되지 않았거나, 또는 (ⅲ) 그렇지 않으면 메소드 호출시 활성화가 허용되지 않는다면, 'setMultiScreenConfiguration()' 메소드(1682)는 'java.lang.IllegalStateException'를 발생시킨다.
'setMultiScreenConfiguration()' 메소드(1682)는 MSM I01 버전으로부터 적용된다.
'requestMultiScreenConfigurationChange' 메소드(1674)는 'public void requestMultiScreenConfigurationChange(MultiScreenConfiguration configuration, java.util.Dictionary serviceContextAssociations)'로 선언되며, 현재 활성 플랫폼별 디스플레이 멀티스크린 설정의 변경을 요청한다.
해당 'configuration'이 현재 설정이고, 'SecurityException'이 적용되지 않는다면, 'requestMultiScreenConfigurationChange' 메소드(1674)는 다른 부수적 효과 없이 값을 반환한다.
해당 'configuration'이 현재 플랫폼별 디스플레이 멀티스크린 설정이 아니고, 'SecurityException', 'IllegalArgumentException', 및 'IllegalStateException'이 적용되지 않는다면, 'requestMultiScreenConfigurationChange' 메소드(1674)는 현재 플랫폼별 멀티스크린 설정으로의 비동기적 변경을 초기화하며, 여기서 'MultiScreenConfiguration.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트가 (전달되기 이전에) 생성된 이후 즉시 'requestMultiScreenConfigurationChange' 메소드(1674)가 값을 반환하여야 하는 경우를 제외하면, 'setMultiScreenConfiguration()' 메소드(1682)의 시맨틱들이 적용된다.
'configuration' 파라미터는 현재 활성 스크린 설정이 되는 'MultiScreenConfiguration' 인스턴스이다. 'serviceContextAssociations' 파라미터는, 상기 'setMultiScreenConfiguration(..)'에 의해 정의된 시맨틱에 따라, 'null' 값, 또는 그 키들이 'ServiceContext' 인스턴스들이고 그 값들이 스트링 값 들인 'Dictionary' 인스턴스이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않는다면, 'requestMultiScreenConfigurationChange' 메소드(1674)는 'java.lang.SecurityException'를 발생시킨다.
(ⅰ) MSM 구현이 해당 멀티스크린 설정의 활성화를 허용하지 않거나, (ⅱ) 'requestMultiScreenConfigurationChange' 메소드(1674)가 이전에 호출되고 변경 처리 과정이 아직 완료되지 않거나, (ⅲ) 그렇지 않으면 메소드 호출시 활성화가 허용되지 않는다면, 'requestMultiScreenConfigurationChange' 메소드(1674)는 'java.lang.IllegalStateException'를 발생시킨다.
'requestMultiScreenConfigurationChange' 메소드(1674)는 MSM I01 버전으로부터 적용된다.
'addMultiScreenConfigurationListener' 메소드(1632)는 'public void addMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'로 선언되며, 멀티스크린 설정 이벤트들의 발생시 통지 받는 리스너들을 부가한다. 리스너가 이전에 부가된 후 제거되지 않았다면, 리스너를 다시 부가하려는 시도에 대해 어떤 반응도 있어서는 안 된다.
이러한 'MultiScreenManager' 싱글턴 인스턴스에 적용되는 설정 이벤트들은 사용가능한 디스플레이 스크린들의 완성에 영향을 미치는 이벤트들로 제한되어야 한다.
'MultiScreenConfigurationEvent'에 의해 정의되는 이벤트가 생성된다면, 이 에 따라 MSM 구현은 각각의 등록된 스크린 설정 리스너에 통지하여야 한다.
'listener' 파라미터는 'MultiScreenConfigurationListener' 인스턴스이다.
'addMultiScreenConfigurationListener' 메소드(1632)는 MSM I01 버전으로부터 적용된다.
'removeMultiScreenConfigurationListener' 메소드(1668)는 'public void removeMultiScreenConfigurationListener(MultiScreenConfigurationListener listener)'로 선언되며, 멀티스크린 설정 이벤트들의 발생시 통지받기 위해 이전에 부가되었던 리스너를 제거한다. 지정된 리스너가 리스너로 현재 등록되지 않았다면, 이를 제거하려는 시도에 대해 어떤 반응도 있어서는 안 된다.
'listener' 파라미터는 'MultiScreenConfigurationListener' 인스턴스이다.
'removeMultiScreenConfigurationListener' 메소드(1668)는 MSM I01 버전으로부터 적용된다.
'addResourceStatusListener' 메소드(1636)는 'public void addResourceStatusListener(org.davic.resources.ResourceStatusListener listener)'로 선언되며, 리소스 상태 리스너를 부가한다.
'listener' 파라미터는 'ResourceStatusListener' 인스턴스이다.
'addResourceStatusListener' 메소드(1636)는 MSM I01 버전으로부터 적용된다.
'removeResourceStatusListener' 메소드(1672)는 'public void removeResourceStatusListener(org.davic.resources.ResourceStatusListener listener)'로 선언되며, 리소스 상태 리스너를 제거한다.
'listener' 파라미터는 'ResourceStatusListener' 인스턴스이다.
'removeResourceStatusListener' 메소드(1672)는 MSM I01 버전으로부터 적용된다.
'swapServiceContexts' 메소드(1684)는 'public void swapServiceContexts(org.havi.ui.HScreen screen1, org.havi.ui.HScreen screen2, javax.tv.service.selection.ServiceContext[] exclusions)'로 선언되며, 두 'HScreen' 인스턴스들 사이의 서비스 컨텍스트들을 세세하게 교체한다.
'swapServiceContexts' 메소드(1684)는 스크린들 사이의 컨텐츠 재생을 교체하는 공통 기능을 지원하기 위한 편의적 메소드이다. 'swapServiceContexts' 메소드(1684)에 의해 발생되는 유사한 결과들은, 'MultiScreenConfigurableContext.addServiceContext(..)' 메소드 및 'MultiScreenConfigurableContext.removeServiceContext(..)' 메소드를 사용함으로써 서비스 컨텍스트들을 제거하고 소정 억세스 가능한 스크린들에 부가하는 더 일반적인 메커니즘에 의해서도 발생될 수 있다. 그럼에도 불구하고, 'swapServiceContexts' 메소드(1684)는 'swapServiceContexts' 메소드(1684)의 세세한 교체 시맨틱들 덕분에, 상기 더 일반적인 메소드를 사용할 때 발생할 수 있는 더 많은 재생 전송 결함들을 방지할 수 있다.
'swapServiceContexts' 메소드(1684)에 의해 교체될 서비스 컨텍스트와 연관된 비디오를 처리하기 위해 사용될 비디오 파이프라인 디코더 포맷 변환(DFC) 설정 부의 상태는 'swapServiceContexts' 메소드(1684)의 수행 여부에 영향을 받아서는 안 된다.
'screen1' 파라미터는, 그 서비스 컨텍스트들이 'screen2'의 서비스 컨텍스트들과 교체되는 'HScreen' 인스턴스이다.
'screen2' 파라미터는, 그 서비스 컨텍스트들이 'screen1'의 서비스 컨텍스트들과 교체되는 'HScreen' 인스턴스이다.
'exclusions' 파라미터는 'null' 값이 아니라면, 교체 작업으로부터 제외되는 'ServiceContext' 인스턴스들, 즉 그 스크린 연관 관계가 교체 작업에 의해 영향을 받지 않는 인스턴스들의 비지 않은 어레이이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않는다면, 'swapServiceContexts' 메소드(1684)는 'java.lang.SecurityException'를 발생시킨다.
(ⅰ) 비디오가 스크린 내의 백그라운 비디오가 아닌 구성 비디오로써 재생될 것이거나, (ⅱ) 해당 스크린들을 위한 'ServiceContext'들이 변경될 수 없다면, 즉 플랫폼이 소정 'ServiceContext' 및 스크린의 영구적인 연관 관계를 사용한다는 조건 중 하나가 만족된다면, 'swapServiceContexts' 메소드(1684)는 'java.lang .IllegalStateException'를 발생시킨다.
'swapServiceContexts' 메소드(1684)는 MSM I01 버전으로부터 적용된다.
'moveServiceContexts' 메소드(1666)는 'public void moveServiceContexts(org.havi.ui.HScreen src, org.havi.ui.HScreen dst, javax.tv.service.selection.ServiceContext[] contexts)'로 선언되면, 소정 서비스 컨텍스트를 하나의 'HScreen' 인스턴스를 또 다른 'HScreen' 인스턴스로 세세하게 이동한다.
'moveServiceContexts' 메소드(1666)는 주어진 서비스 컨텍스트들을 위한 스크린들 사이의 컨텐츠 재생을 이동시키는 공통 기능을 지원하기 위한 편의적 메소드이다. 'moveServiceContexts' 메소드(1666)에 의해 발생되는 유사한 결과들은, 'MultiScreenConfigurableContext.addServiceContext(..)' 메소드 및 'MultiScreenConfigurableContext.removeServiceContext(..)' 메소드를 사용함으로써 서비스 컨텍스트들을 제거하고 소정 억세스 가능한 스크린들에 부가하는 더 일반적인 메커니즘에 의해 역시 발생될 수 있다. 그럼에도 불구하고, 'moveServiceContexts' 메소드(1666)의 세세한 교체 시맨틱들 덕분에 'moveServiceContexts' 메소드(1666)를 사용하면, 더 일반적인 메소드를 사용함으로써 발생할 수 있는 더 많은 재생 전송 결함들을 방지할 수 있다.
'moveServiceContexts' 메소드(1666)에 의해 이동될 서비스 컨텍스트와 연관된 비디오를 처리하기 위해 사용될 비디오 파이프라인 디코더 포맷 변환(DFC) 설정부의 상태는 'moveServiceContexts' 메소드(1666)의 수행 여부에 영향을 받아서는 안 된다.
'src' 파라미터는 'HScreen' 인스턴스이며, 'src' 파라미터로부터 그 서비스 컨텍스트들이 이동된다.
'dst' 파라미터는 'HScreen' 인스턴스이며, 'dst' 파라미터로 그 서비스 컨 텍스트들이 이동된다.
'contexts' 파라미터는 'src' 스크린으로부터 'dst' 스크린으로 이동될 'ServiceContext' 인스턴스들의 비지 않은 어레이를 나타낸다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않는다면, 'moveServiceContexts' 메소드(1666)는 'java.lang.SecurityException'를 발생시킨다.
일부 지정된 'ServiceContext'가 소스 'HScreen' 인스턴스, 'src',와 현재 연관되지 않았다면, 'moveServiceContexts' 메소드(1666)는 'java.lang.IllegalArgumentException'를 발생시킨다.
(ⅰ) 비디오가 스크린 내의 백그라운 비디오가 아닌 구성 비디오로써 재생될 것이거나, (ⅱ) 지정된 스크린들을 위한 일부 지정된 'ServiceContext'들이 이동될 수 없다면, 즉 플랫폼이 소정 'ServiceContext' 및 스크린의 영구적인 연관 관계를 사용하거나, (ⅲ) 비추상 'ServiceContext'가 목적지 스크린과 이미 연관되어 있고, 플래폼이 스크린마다 오직 비추상 'ServiceContext'를 지원하는 경우 중 어느 한 경우이라도 만족된다면, 'moveServiceContexts' 메소드(1666)는 'java.lang .IllegalStateException'를 발생시킨다.
'moveServiceContexts' 메소드(1666)는 MSM I01 버전으로부터 적용된다.
'getPlayerScreenDevices' 메소드(1658)는 'public org.havi.ui.HScreenDevice[] getPlayerScreenDevices(javax.media.Player player)'로 선언되며, (JMF) 미디어 플레이어에 의한 사용을 위해 현재 지정된 스 크린 디바이스들를 획득한다.
'player' 파라미터는 스크린 디바이스들를 위해 획득하는 'JMF Player' 인스턴스이다.
'getPlayerScreenDevices' 메소드(1658)는 'HScreenDevice' 인스턴스들의 어레이이며, 연관된 스크린 디바이스가 없을 때 또는 없을 때만 빈 어레이어야 한다.
'getPlayerScreenDevices' 메소드(1658)는 MSM I01 버전으로부터 적용된다.
'addPlayerScreenDevices' 메소드(1634)는 'public void addPlayerScreenDevices(javax.media.Player player, org.havi.ui.HScreenDevice[] devices)'로 선언되며, 스크린 디바이스(들)을 미디어 플레이어에 부가한다.
'player' 파라미터는 해당 스크린 디바이스(들)을 위해 조회(query)될 'JMF Player' 인스턴스이다. Devices 파라미터는 지정된 미디어 플레이어로부터 재생된 컨텐츠의 일부 타입을 재생하기 위한 'HScreenDevice' 인스턴스의 비지 않은 어레이이다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않는다면, 'addPlayerScreenDevices' 메소드(1634)는 'java.lang.SecurityException'를 발생시킨다.
(ⅰ) 해당 'player'가 정지된 상태가 아닌 경우, (ⅱ) 해당 스크린 'device' 가 해당 'device'와 호환되지 않는 경우, (ⅲ) 'device'들의 일부 기저 스크린 디바이스가 (예를 들어 또 다른 어플리케이션에 의해 배타적으로 예약 할당되어서) 해당 어플리케이션이 사용할 수 없는 경우, (ⅳ) 'device'들의 일부 기저 스크린 디바이스가 미디어 플레이어와 이미 연관되어 상기 디바이스가 복수 개의 미디어 플레이어들과의 연관을 지원하지 않는 경우 중 적어도 하나의 경우, 'addPlayerScreenDevices' 메소드(1634)는 'java.lang. IllegalStateException'를 발생시킨다.
'addPlayerScreenDevices' 메소드(1634)는 MSM I01 버전으로부터 적용된다.
'addPlayerScreenDevices' 메소드(1634)에 대한 더 자세한 정보는 'Player', 'HScreenDevice' 인스턴스를 참조하면 얻어진다.
'removePlayerScreenDevices' 메소드(1670)는 'public void removePlayerScreenDevices(javax.media.Player player, org.havi.ui.HScreenDevice[] devices)'로 선언되며, 미디어 플레이어로부터 스크린 디바이스(들)을 제거한다. 즉, 지정된 미디어 플레이어가 재생되고 있는 (또는 그렇지 않으면 재생과 연관되어 있는) 스크린 디바이스들로부터 모든 'HScreenDevice' 인스턴스들 또는 비지 않은 'HScreenDevice' 인스턴스들이 제거된다. 'devices'이 'null' 값이라면, 모든 스크린 디바이스 연관 관계가 제거된다.
호출 스레드에 대해 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않는다면, 'removePlayerScreenDevices 메소드(1670)'는 'java.lang.SecurityException'를 발생시킨다.
'devices'이 'null' 값이 아니고 'devices'의 일부 엔트리가 지정된 'Player' 인스턴스와 연관되지 않는다면, 'removePlayerScreenDevices' 메소드(1670)는 java.lang.IllegalArgumentException를 발생시킨다.
해당 player가 정지된 상태가 아니라면, removePlayerScreenDevices 메소드(1670)는 java.lang.IllegalStateException를 발생시킨다.
removePlayerScreenDevices 메소드(1670)는 MSM I01 버전으로부터 적용된다.
getEmptyScreen() 메소드(1644)는 'public org.havi.ui.HScreen getEmptyScreen()'로 선언되며, 빈 싱글턴 'HScreen' 인스턴스를 획득한다.
상기 빈 'HScreen'를 이용하여, 'getEmptyScreen()' 메소드(1644)는, 'HScreen' 인스턴스의 각각의 이용 가능한 서브타입, 즉 'HBackgroundDevice', 'HVideoDevice', 'HGraphicsDevice' 등의 빈 'HScreenDevice', 빈 'HScreenConfiguration' 및 빈 'HScreenConfigTemplate'에 대한 참조를 획득할 수 있다.
'getEmptyScreen' 메소드(1644)의 존재는 주로 'isEmptyScreen()', 'isEmptyScreenDevice()', 'sameResources()' 등과 같이 MSM 기능성을 시험하는 기능을 지원하기 위함이다.
'getEmptyScreen()' 메소드(1644)는, 빈 HScreen 싱글턴을 반환한다.
'getEmptyScreen()' 메소드(1644)는 MSM I01 버전으로부터 적용된다.
'isEmptyScreen' 메소드(1662)는 'public boolean isEmptyScreen(org.havi.ui.HScreen screen)'로 선언되며, 제한 요건으로써 'HScreen'의 인스턴스가 빈 'HScreen'과 동일한지 여부를 결정한다.
'screen'이 'MultiScreenConfigurableContext'를 구현하지 않는다면, 'MultiScreenConfigurableContext'에 관련된 제한 요건들은 동일하다고 간주되어야 해야 한다.
'screen' 파라미터는 'HScreen' 인스턴스이다.
'isEmptyScreen' 메소드(1662)는, 해당 'screen'가 빈 'HScreen'과 동일하다면 '참' 값을 반환한다.
'isEmptyScreen' 메소드(1662)는 MSM I01 버전으로부터 적용된다.
'isEmptyScreenDevice' 메소드(1664)는 'public boolean isEmptyScreenDevice(org.havi.ui.HScreenDevice device)'로 선언되며, 제한 요건으로써 'HScreenDevice'의 인스턴스가 소정 서브타입의 빈 'HScreenDevice'과 동일한지 여부를 결정한다.
'device' 파라미터는 'HBackgroundDevice',
'HVideoDevice', 또는 'HGraphicsDevice' 서브타입 중 하나의 'HScreenDevice' 인스턴스이다.
해당 'device'가 부합하는 서브타입의 빈 'HScreenDevice'과 동일하다면, 'isEmptyScreenDevice' 메소드(1664)는 '참' 값을 반환한다.
'isEmptyScreenDevice' 메소드(1664)는 MSM I01 버전으로부터 적용된다.
'sameResources(HScreen, HScreen)' 메소드(1678)는 'public boolean sameResources(org.havi.ui.HScreen screen1, org.havi.ui.HScreen screen2)'로 선언되며, 두 개의 'HScreen' 인스턴스가 동일한 기저 플랫폼 리소스들 및 기저 리소스 상태를 나타내는지 여부, 즉 이러한 기저 리소스들의 관점에서 동일성이 있는지 여부를 결정한다.
동일성을 결정하기 위해, 아래 조건이 적용되어야 한다.
- 'screen1' 및 'screen2' 중 단 하나가 빈 'HScreen'과 동일하다면, 두 스크린들은 기저 리소스들의 관점에서 동일성이 없다;
- 'screen1.getHBackgroundDevices()'에 의해 반환된 각각의 스크린 디바이스, 'BD1'에 대해, 'sameResources(BD1,BD2)'가 '참' 값을 반환하도록 하는, 'screen2.getHBackgroundDevices()'에 의해 반환된 단 하나의 스크린 디바이스, 'BD2'이 없으면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다
- 'screen1.getHVideoDevices()'에 의해 반환된 각각의 스크린 디바이스, 'VD1'에 대해, 'sameResources(VD1,VD2)'가 '참' 값을 반환하도록 하는, 'screen2.getHVideoDevices()'에 의해 반환된 단 하나의 스크린 디바이스, 'VD2'이 없으면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다
- 'screen1.getHGraphicsDevices()'에 의해 반환된 각각의 스크린 디바이스, 'GD1'에 대해, 'sameResources(GD1,GD2)'가 '참' 값을 반환하도록 하는, 'screen2.getHGraphicsDevices()'에 의해 반환된 단 하나의 스크린 디바이스, 'GD2'가 없으면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다
- 동일한 템플릿 인자들이 주어진 경우, 'screen1.getBestConfiguration(..)' 및 'screen2.getBestConfiguration(..)'가 (명목상 순서없이) 동일한 'HScreenConfiguration' 인스턴스들을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다
- 동일한 스크린 설정 인자들이 주어진 경우, 'screen1.getCoherentScreenConfigurations(..)' 및 'screen2.getCoherentScreenConfigurations(..)'가 동일한 'HScreenConfiguration' 인스턴스들을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다
- 동일한 스크린 설정 인자들이 주어진 경우, 'screen1.setCoherentScreenConfigurations(..)' 및 'screen2.setCoherentScreenConfigurations(..)'이 동일한 값을 반환하지 않거나, 또는 스크린 디바이스들이 동일성이 있도록 해당 스크린 설정 인자들과 연관된 스크린 디바이스들을 변경하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다
- 상기 요건들 중 어느 것도 적용되지 않는다면, 'screen1' 및 'screen2'는 기저 리소스들의 관점에서 동일하다고 간주된다.
'screen1' 파라미터 및 'screen2' 파라미터는 'HScreen' 인스턴스이다.
해당 스크린들이 상기 조건들에 기술된 대로 동일성이 있다면, '참' 값이 반환된다.
'sameResources(HScreen, HScreen)' 메소드(1678)는 MSM I01 버전으로부터 적용된다.
'sameResources(HScreenDevice, HScreenDevice)' 메소드(1676)는 'public boolean sameResources(org.havi.ui.HScreenDevice device1, org.havi.ui.HScreenDevice device2)'로 선언되며, 두 개의 'HScreenDevice' 인스 턴스가 동일한 기저 플랫폼 리소스들 및 기저 리소스 상태를 나타내는지 여부, 즉 이러한 기저 리소스들의 관점에서 동일성이 있는지 여부를 결정한다.
동일성을 결정하기 위해, 아래 조건이 적용되어야 한다.
- 'device1' 및 'device2'가 동일한 서브타입, 즉 'HBackgroundDevice', 'HVideoDevice', or 'HGraphicsDevice', 이 아니라면, 두 스크린 디바이스들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1' 및 'device2' 중 단 하나만이 해당 서브타입의 빈 'HScreenDevice'와 동일하다면, 두 스크린 디바이스들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1.getFlickerFilter()' 메소드 및 'device2.getFlickerFilter()' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린 디바이스들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1.getInterlaced()' 메소드 및 'device2.getInterlaced()' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린 디바이스들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1.getPixelAspectRatio()' 메소드 및 'device2.getPixelAspectRatio()' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린 디바이스들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1.getScreenArea()' 메소드 및 'device2.getScreenArea()' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린 디바이스들은 기저 리소스들의 관점 에서 동일하지 않다;
- 인자로써 동일한 'HScreenConfiguration' 인스턴스들, 'SC1' 및 'SC2',가 주어진 경우, 'device1.getOffset(SC1)' 메소드 및 'device2.getOffset(SC2)' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린 디바이스들은 기저 리소스들의 관점에서 동일하지 않다;
- 인자로써 동일한 'HScreenConfiguration' 인스턴스들 'SC1' 및 'SC2', 및 'Point' 인스턴스들 'P1' 및 'P2'가 주어진 경우, 'device1.convertTo(SC1,P1)'와 'device2.convertTo(SC2, P2)' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1.getConfigurations()' 메소드 및 'device2.getConfigurations()' 메소드가 (명목상 순서 없는) 동일한 'HScreenConfiguration' 인스턴스들을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1.getCurrentConfiguration()' 메소드 및 'device2.getCurrentConfiguration()' 메소드가 동일한 'HScreenConfiguration' 인스턴스들을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1.getDefaultConfiguration()' 메소드 및 'device2.getDefaultConfiguration()' 메소드가 동일한 'HScreenConfiguration' 인스턴스들을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 동일성 있는 템플릿 인자들 또는 템플릿 인자들이 주어진 경우, 'device1.getBestConfiguration(..)' 메소드 및 'device2.getBestConfiguration(..)' 메소드가 동일한 'HScreenConfiguration' 인스턴스들을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1' 및 'device2'가 'HBackgroundDevice' 인스턴스들이고, 동일성 있는 'HBackgroundConfiguration' 인스턴스들이 인자로써 지정된 경우 'device1.setBackgroundConfiguration(..)' 메소드 및 'device2.setBackgroundConfiguration(..)' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1' 및 'device2'가 'HVideoDevice' 인스턴스들이고, (ⅰ) 동일성 있는 'HVideoConfiguration' 인스턴스들이 인자로써 지정된 경우, 'device1.setVideoConfiguration(..)' 메소드 및 'device2.setVideoConfiguration(..)' 메소드가 동일한 값을 반환하지 않는 경우, (ⅱ) 'device1.getVideoSource()' 메소드 및 'device1.getVideoSource()' 메소드가 명목상 동일한 비디오 소스들을 반환하지 않는 경우, 또는 (ⅲ) 'device1.getVideoController()' 메소드 및 'device1.getVideoController()' 메소드가 명목상 동일성 있는 비디오 컨트롤러를 반환하지 않는 경우 중 어느 한 경우라면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 'device1' 및 'device2'가 'HGraphicsDevice' 인스턴스들이고, 동일성 있 는 'HGraphicsConfiguration' 인스턴스들이 인자로써 지정된 경우 'device1.setGraphicsConfiguration(..)' 메소드 및 'device2.setGraphicsConfiguration(..)' 메소드가 동일한 값을 반환하지 않는다면, 두 스크린들은 기저 리소스들의 관점에서 동일하지 않다;
- 상기 조건 중 하나도 적용되지 않는다면, 'device1' 및 'device2'는 기저 리소스들의 관점에서 동일하다고 간주된다.
'device1' 파라미터 및 'device2' 파라미터는 'HScreenDevice' 인스턴스이다.
지정된 스크린들이 상기 조건들에 기술된 대로 동일성이 있다면, 'sameResources(HScreenDevice, HScreenDevice)' 메소드(1676)는 '참' 값을 반환한다.
'sameResources(HScreenDevice, HScreenDevice)' 메소드(1676)는 MSM I01 버전으로부터 적용된다.
'sameResources(ServiceContext, ServiceContext)' 메소드(1680)는 'public boolean sameResources(javax.tv.service.selection.ServiceContext sc1, javax.tv.service.selection.ServiceContext sc2)'로 선언되며, 두 개의 'ServiceContext' 인스턴스가 동일한 기저 플랫폼 리소스들 및 기저 리소스 상태를 나타내는지 여부, 즉 이러한 기저 리소스들의 관점에서 동일성이 있는지 여부를 결정한다.
'sc1' 파라미터 및 'sc2' 파라미터는 ServiceContext 인스턴스이다.
지정된 서비스 컨텍스트들이 동일성이 있다면(즉, 동일한 기저 리소스들 및 리소스 상태를 나타낸다면), 'sameResources(ServiceContext, ServiceContext)' 메소드(1680)에 의해 '참' 값이 반환된다.
'sameResources(ServiceContext, ServiceContext)' 메소드(1680)는 MSM I01 버전으로부터 적용된다.
'getInstance()' 메소드(1646)는 'public static MultiScreenManager getInstance()'로 선언되며, 'MultiScreenManager'의 싱글턴 인스턴스를 획득한다. 'MultiScreenManager' 인스턴스가 반환된다.
'getInstance()' 메소드(1646)는 MSM I01 버전으로부터 적용된다.
도 17 은 본 발명의 일 실시예에 따른 자바 패키지 'org.ocap.ui.event'의 인터페이스 및 클래스를 도시한다.
'org.ocap.ui.event' 패키지는 OCAP의 특정 리모트 컨트롤 이벤트들(remote control events) 및 멀티스크린 매니지먼트 이벤트들을 포함하는 HAVi 유저 인터페이스 이벤트 클래스(HAVi User Interface Event classe)으로의 확장형이다.
'org.ocap.ui.event' 패키지의 인터페이스(1700)는 'MultiScreenConfigurationListener' 인터페이스(1702) 및 'MultiScreenContextListener' 인터페이스(1704) 중 적어도 하나를 포함한다.
'MultiScreenConfigurationListener' 인터페이스(1702)는, 'MultiScreenManager' 인스턴스의 총체적 상태 또는 플랫폼별 또는 일부 디스플레이별 멀티스크린 설정 각각에 관한 일부 디스플레이 'HScreen'의 상태로 시스템 및 어플리케이션이 발생시킨 변경, 또는 소정 'MultiScreenConfiguration' 인스턴스로의 변경들에 관한 통지를 제공하기 위해 사용된다.
'MultiScreenContextListener' 인터페이스(1704)는 시스템 및 어플리케이션이 발생시킨 'MultiScreenContext'으로의 변경에 관한 통지를 제공하기 위해 사용된다.
'org.ocap.ui.event' 패키지의 클래스(1710)는 'MultiScreenConfigurationEvent' 클래스(1712), 'MultiScreenContextEvent' 클래스(1714), 'MultiScreenEvent' 클래스(1716) 및 'MultiScreenResourceEvent' 클래스(1718) 중 적어도 하나를 포함한다.
'MultiScreenConfigurationEvent' 클래스(1712)는, 'MultiScreenManager' 인스턴스의 총체적인 상태, 또는 플랫폼별 또는 일부 디스플레이별 멀티스크린 설정 각각에 관한 일부 디스플레이 'HScreen' 상태로의 변경 또는 소정 'MultiScreenConfiguration' 인스턴스로의 변경들을 보고하기 위해 사용된다.
'MultiScreenContextEvent' 클래스(1714)는 'MultiScreenContext'의 변경을 관심있는 리스너들로 보고하기 위해 사용된다.
'MultiScreenEvent' 클래스(1716)는 멀티플 스크린 매니지먼트 기능성과 관련된 다른 종류의 타입들의 이벤트들의 의해 사용되는 이벤트 식별 코드들을 설정하기 위해 사용되는 추상적인 기본 클래스이다.
'MultiScreenResourceEvent' 클래스(1718)는 멀티스크린 관련 리소스들의 리소스 상태에 관한 변경들을 보고하기 위해 사용된다.
도 18a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 정의를 도시한다.
'org.ocap.ui.event.MultiScreenConfigurationEvent' 자바 타입은 'java.lang.Object, java.util.EventObject'의 하위 레벨인 'org.ocap.ui.event.MultiScreenEvent', 또 그 하위 레벨인 'org.ocap.ui.event.MultiScreenConfigurationEvent'의 하위 레벨로 정의된다.
'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스는, 모든 구현된 인터페이스(All Implemented Interfaces)로 'java.io.Serializable'를 포함하며, 'public class MultiScreenConfigurationEvent'로 선언되고, 'extends MultiScreenEvent'로 확장된다.
'MultiScreenConfigurationEvent' 클래스(1712)는, 'MultiScreenManager' 인스턴스의 총체적인 상태, 또는 플랫폼별 또는 일부 디스플레이별 멀티스크린 설정 각각에 관한 일부 디스플레이 'HScreen' 상태로의 변경 또는 소정 'MultiScreenConfiguration' 인스턴스로의 변경들을 보고하기 위해 사용된다.
이하의 변경 타입들이 'MultiScreenConfigurationEvent'(1712)를 발생시킨다.
- 'MultiScreenManager'가 하나의 멀티스크린 설정에서 또 다른 멀티스크린 설정으로 변경됨으로써 결정되는 현재 활성 플랫폼별 멀티스크린 설정;
- 일부 디스플레이 'HScreen' 이 하나의 멀티스크린 설정에서 또 다른 멀티스크린 설정으로 변경됨으로써 결정되는 현재 활성 디스플레이별 멀티스크린 설정;
- 'MultiScreenConfiguration' 변경들(즉, 스크린이 부가되거나, 멀티스크린 설정으로부터 제거되는 변경들)과 연관된 스크린들.
'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스(1712)는 MSM I01 버전으로부터 적용된다.
도 18b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 필드를 도시한다.
'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스(1712)의 필드(1800)는 'static int MULTI_SCREEN_CONFIGURATION_CHANGED'(1802), 'static int MULTI_SCREEN_CONFIGURATION_CHANGING'(1804), 'static int MULTI_SCREEN_CONFIGURATION_LAST'(1806), 'static int MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED'(1808), 및 'static int MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED'(1810) 중 적어도 하나를 포함한다.
'org.ocap.ui.event.MultiScreenEvent' 클래스(1716)로부터 상속된 필드들(1820)은 'MULTI_SCREEN_CONFIGURATION_FIRST', 및 'MULTI_SCREEN_CONTEXT_FIRST' 중 적어도 하나를 포함한다.
'java.util.EventObject' 클래스로부터 상속된 필드들(1825)은 'Source'를 포함한다.
'MULTI_SCREEN_CONFIGURATION_CHANGING' 필드(1804)는 'public static final int MULTI_SCREEN_CONFIGURATION_CHANGING'로 선언된다. 'MultiScreenManager' 또 는 일부 디스플레이 'HScreen'에 의해 결정된 현재 활성 플랫폼별 또는 일부 디스플레이별 'MultiScreenConfiguration'으로의 변경이 초기화된 경우, 'getSource()' 메소드에 의해 반환되는 값은 영향받는 MultiScreenManager 또는 디스플레이 HScreen이어야 하고, 'getRelated()' 메소드에 의해 반환되는 값은 차후의 활성 'MultiScreenConfiguration'이어야 한다.
'MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트(1804)는 'MonitorAppPermission("multiscreen.configuration")'가 허용되지 않은 어플리케이션으로 전달되어서는 안 된다.
'MULTI_SCREEN_CONFIGURATION_CHANGING' 필드(1804)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONFIGURATION_CHANGED' 필드(1802)는 'public static final int MULTI_SCREEN_CONFIGURATION_CHANGED'로 선언된다. 'MultiScreenManager' 또는 일부 디스플레이 'HScreen'에 의해 결정되는 현재 활성 플랫폼별 또는 일부 디스플레이별 'MultiScreenConfiguration'이 변경된 경우, 'getSource()' 메소드에 의해 반환되는 값은 영향받는 'MultiScreenManager' 또는 디스플레이 'HScreen'이어야 하고, 'getRelated()' 메소드에 의해 반환되는 값은 이전의 활성 'MultiScreenConfiguration'이어야 한다.
'MULTI_SCREEN_CONFIGURATION_CHANGED' 필드(1802)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED' 필드(1808)는 'public static final int MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED'로 선언된다. 'MultiScreenConfiguration'에 새로운 스크린이 부가되어, 'MultiScreenConfiguration'과 연관된 스크린들이 변경된 경우, 'getSource()' 메소드에 의해 반환되는 값은 이에 영향 받은 'MultiScreenConfiguration'이고, 'getRelated()' 메소드에 의해 반환되는 값은 새로 추가된 'HScreen'이어야 한다.
'MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트(1804)의 마지막 전송과 관련 'MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트(1802)의 생성 사이의 기간 동안을 제외하고, 스크린이 현재 플랫폼별 또는 일부 현재 디스플레이별 멀티스크린 설정인 멀티스크린 설정에 대해 부가되어서는 안 되고, 상기 멀티스크린 설정에 대해 'MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED' 이벤트(1808)가 생성되어서도 안 된다.
'MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED' 필드(1808)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED' 필드(1810)는 'public static final int MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED'로 선언된다. 'MultiScreenConfiguration'의 현존 스크린이 제거되어 'MultiScreenConfiguration'과 연관된 스크린들이 변경된 경우, 'getSource()' 메소드에 의해 반환되는 값은 영향받는 'MultiScreenConfiguration'이어야 하고, 'getRelated()' 메소드에 의해 반환되는 값은 새로 제거된 'HScreen'이어야 한다.
'MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트(1804)의 마지막 출력과 관련 'MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트(1802)의 생성 사이의 기간 동안을 제외하고, 스크린이 현재 플랫폼별 또는 일부 현재 디스플레이별 멀티스크린 설정인 멀티스크린 설정으로부터 제거되어서는 안 되고, 상기 멀티스크린 설정에 대해 'MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED' 이벤트(1810)가 생성되어서도 안 된다.
'MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED' 필드(1810)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONFIGURATION_LAST' 필드(1806)는 'public static final int MULTI_SCREEN_CONFIGURATION_LAST'로 선언되며, 'MultiScreenConfigurationEvent' 이벤트 식별자에 지정된 지난 이벤트 식별자이다.
'MULTI_SCREEN_CONFIGURATION_LAST' 필드(1806)는 MSM I01 버전으로부터 적용된다.
도 18c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 생성자를 도시한다.
'MultiScreenConfigurationEvent' 생성자(1830)는 'public MultiScreenConfigurationEvent(java.lang.Object source, int id, java.lang.Object related)'로 선언되며, 'MultiScreenConfigurationEvent(1832)'를 생성한다.
'source' 파라미터는 전술된 소정 이벤트에 따른 'MultiScreenManager' 인스턴스, 디스플레이 'HScreen' 인스턴스, 또는 'MultiScreenConfiguration' 인스턴스 에 대한 참조값이다.
'id' 파라미터는 상기 이벤트의 이벤트 식별자이며, 그 값은 'MULTI_SCREEN_CONFIGURATION_CHANGING'(1804), 'MULTI_SCREEN_CONFIGURATION_CHANGED'(1802), 'MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED'(1808), 및 'MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED'(1810) 중 어느 하나이어야 한다.
'related' 파라미터는 전술된 소정 이벤트에 따른 'MultiScreenConfiguration' 인스턴스 또는 'HScreen' 인스턴스에 대한 참조값이다.
'MultiScreenConfigurationEvent' 생성자(1830)는 MSM I01 버전으로부터 적용된다.
도 18d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 메소드를 도시한다.
'org.ocap.ui.event.MultiScreenConfigurationEvent' 클래스(1712)의 메소드(1840)는 'java.lang.Object getRelated()'(1842)를 포함하며, 'org.ocap.ui.event.MultiScreenEvent' 클래스로부터 상속된 메소드(1850)는 'getId'를 포함하고, 'java.util.EventObject' 클래스로부터 상속된 메소드(1852)는 'getSource' 및 'toString' 중 적어도 하나를 포함한다. 'java.lang.Object' 클래스로부터 상속된 메소드(1854)는 'clone', 'equals', 'finalize', 'getClass', 'hashCode', 'notify', 'notifyAll', 'wait', 'wait', 'wait' 중 적어도 하나를 포 함한다.
'getRelated()' 메소드(1842)는 'public java.lang.Object getRelated()'로 선언되며, 상기 이벤트의 관련 객체를 획득한다. 즉, 'getRelated()' 메소드(1842)는 상기 이벤트의 관련 객체 인스턴스를 반환하며, 소정 이벤트 타입에 의해 결정되는 'MultiScreenConfiguration' 인스턴스에 대한 참조 또는 'HScreen' 인스턴스에 대한 참조 중 하나이어야 한다.
'getRelated()' 메소드(1842)는 MSM I01 버전으로부터 적용된다.
도 19a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationListener' 인터페이스의 정의를 도시한다.'
'org.ocap.ui.event.MultiScreenConfigurationListener'(1702)의 슈퍼인터페이스(Superinterfaces)는 'java.util.EventListener'를 포함하며, 'public interface MultiScreenConfigurationListener'로 선언되고, 'extends java.util.EventListener'로 확장된다.
'MultiScreenConfigurationListener' 인터페이스(1702)는, 'MultiScreenManager' 인스턴스의 총체적인 상태 또는 플랫폼별 또는 일부 디스플레이별 멀티스크린 설정 각각에 대한 일부 디스플레이 'HScreen' 상태로 시스템 및 어플리케이션이 발생시킨 변경, 소정 'MultiScreenConfiguration' 인스턴스로의 변경들에 관한 통지를 제공하기 위해 사용된다.
'MultiScreenConfigurationListener' 인터페이스(1702)는 MSM I01 버전으로부터 적용된다.
도 19b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationListener' 인터페이스의 메소드를 도시한다.
'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationListener' 인터페이스(1702)의 메소드(1900)는 'void notify(MultiScreenConfigurationEvent evt)'(1910)를 포함한다.
'notify()' 메소드(1910)는 'void notify(MultiScreenConfigurationEvent evt)'로 선언된다. 'MultiScreenConfigurationEvent'가 생성된 경우, 소정 이벤트 시맨틱에 의해 요청된대로 각각의 리스너에게 이벤트 정보를 보고하기 위해, 상기 구현은 모든 등록된 리스너들에 대해 'notify()' 메소드(1910)를 호출하여야 한다.
이벤트가 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING'인 경우, 해당 리스너를 등록한 어플리케이션에 대해 'MonitorAppPermission("multiscreen.configuration")' 가 허용되지 않았다면, 'notify()' 메소드(1910)는 호출되어서는 안 된다. 더욱이, 모든 적용가능한 리스너들을 위한 'notify()' 메소드(1910)의 호출에 대해 절대 시간 제한이 가해지므로, 'notify()' 메소드(1910)의 구현은 발생할 수 있는 처리량을 크게 제한하여야 한다.
'evt' 파라미터는 'MultiScreenConfigurationEvent' 인스턴스이다.
'notify()' 메소드(1910)는 MSM I01 버전으로부터 적용된다.
도 20a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 정의를 도시한다.
'org.ocap.ui.event.MultiScreenContextEvent' 클래스(1714)는 'java.lang.Object'의 하위 레벨인 'java.util.EventObject', 또 그 하위 레벨인 'org.ocap.ui.event.MultiScreenEvent'의 하위 레벨로 정의된다.
'org.ocap.ui.event.MultiScreenContextEvent' 클래스(1714)의 구현된 인터페이스(All Implemented Interfaces)는 'java.io.Serializable'를 포함하며, 'public class MultiScreenContextEvent'로 선언되고, 'extends MultiScreenEvent'로 확장된다.
'MultiScreenContextEvent' 클래스(1714)는 'MultiScreenContext'로의 변경을 관심있는 리스너들에게 보고하기 위해 사용된다.
이하의 변경 타입들이 'MultiScreenContextEvent'(1714)를 발생시킨다.
- 연관된 'ServiceContext'의 변경;
- 연관된 디스플레이 'HScreen'의 변경;
- 연관된 디스플레이 'HScreen' 영역(범위) 지정의 변경;
- 연관된 'VideoOutputPort'들의 변경;
- 디스플레이 'HScreen'의 오디오 포커스의 변경;
- 스크린 가시성의 변경;
- 스크린 'z-order'의 변경;
- 'HScreen'에 오디오 소스들을 관여시키는 기저 'HScreenDevice'들로의 변경;
- 기저 'HScreenDevice' 인스턴스들의 변경(예를 들면 'HScreenDevice'를 'HScreen'로 부가하거나 'HScreen'으로부터 제거함으로써 발생된 변경);
- 'HScreen'의 기저 'HScreenDevice' 인스턴스들의 'z-order'의 변경.
'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스(1714)는 MSM I01 버전으로부터 적용된다.
도 20b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 필드를 도시한다.
'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스(1714)의 필드는, 'static int MULTI_SCREEN_CONTEXT_AUDIO_FOCUS_CHANGED'(2002), 'static int MULTI_SCREEN_CONTEXT_AUDIO_SOURCES_CHANGED'(2004), 'static int MULTI_SCREEN_CONTEXT_DEVICES_CHANGED'(2006), 'static int MULTI_SCREEN_CONTEXT_DEVICES_Z_ORDER_CHANGED'(2008), 'static int MULTI_SCREEN_CONTEXT_DISPLAY_AREA_CHANGED'(2010), 'static int MULTI_SCREEN_CONTEXT_DISPLAY_SCREEN_CHANGED'(2012), 'static int MULTI_SCREEN_CONTEXT_OUTPUT_PORT_CHANGED'(2014), 'static int MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED'(2016), 'static int MULTI_SCREEN_CONTEXT_VISIBILITY_CHANGED'(2018), 'static int MULTI_SCREEN_CONTEXT_Z_ORDER_CHANGED'(2020), 및 'static int MULTI_SCREEN_CONTEXTS_LAST'(2022) 중 적어도 하나를 포함한다.
'org.ocap.ui.event.MultiScreenEvent' 클래스로부터 상속된 필드(2030)는 'MULTI_SCREEN_CONFIGURATION_FIRST' 및 'MULTI_SCREEN_CONTEXT_FIRST' 중 적어도 하나를 포함한다. 'java.util.EventObject' 클래스로부터 상속된 필드(2035)는 'Source'를 포함한다.
'MULTI_SCREEN_CONTEXT_DEVICES_CHANGED' 필드(2006)는 'public static final int MULTI_SCREEN_CONTEXT_DEVICES_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'과 연관된 'HScreenDevice' 인스턴스들이 변경된 경우에 해당된다.
'MULTI_SCREEN_CONTEXT_DEVICES_CHANGED' 필드(2006)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_DEVICES_Z_ORDER_CHANGED' 필드(2008)는 'public static final int MULTI_SCREEN_CONTEXT_DEVICES_Z_ORDER_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'과 연관된 'HScreenDevice' 인스턴스들의 'z-order'가 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_DEVICES_Z_ORDER_CHANGED' 필드(2008)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED' 필드(2016)는 'public static final int MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'과 연관된 'ServiceContext'가 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED' 필드(2016)는 MSM I01 버 전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_DISPLAY_SCREEN_CHANGED' 필드(2012)는 'public static final int MULTI_SCREEN_CONTEXT_DISPLAY_SCREEN_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'과 연관된 디스플레이 'Hscreen'가 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_DISPLAY_SCREEN_CHANGED' 필드(2012)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_DISPLAY_AREA_CHANGED' 필드(2010)는 'public static final int MULTI_SCREEN_CONTEXT_DISPLAY_AREA_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'이 지정된 디스플레이 'HScreen'의 영역(범위)이 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_DISPLAY_AREA_CHANGED' 필드(2010)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_OUTPUT_PORT_CHANGED' 필드(2014)는 'public static final int MULTI_SCREEN_CONTEXT_OUTPUT_PORT_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'과 연관된 비디오 출력 포트들이 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_OUTPUT_PORT_CHANGED' 필드(2014)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_VISIBILITY_CHANGED' 필드(2018)는 'public static final int MULTI_SCREEN_CONTEXT_VISIBILITY_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'의 가시성이 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_VISIBILITY_CHANGED' 필드(2018)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_Z_ORDER_CHANGED' 필드(2020)는 'public static final int MULTI_SCREEN_CONTEXT_Z_ORDER_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'의 'z-order'가 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_Z_ORDER_CHANGED' 필드(2020)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_AUDIO_SOURCES_CHANGED' 필드(2004)는 'public static final int MULTI_SCREEN_CONTEXT_AUDIO_SOURCES_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'의 오디오 소스들이 변경된 경우에 해당한다.
'MULTI_SCREEN_CONTEXT_AUDIO_SOURCES_CHANGED' 필드(2004)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_AUDIO_FOCUS_CHANGED' 필드(2002)는 'public static final int MULTI_SCREEN_CONTEXT_AUDIO_FOCUS_CHANGED'로 선언되며, 소스 'MultiScreenContext'의 기저 'HScreen'의 오디오 포커스 스크린이 변경된 경우에 해당한다. 디스플레이 'HScreen'의 오디오 포커스 스크린이 변경된 때, (변경이 완료된 후) 상기 이벤트는 두 번 발생되어야 한다. 즉 첫째, 오디오 포커스가 손실된 로지컬 스크린의 (이런 로지컬 스크린이 있다면) 'MultiScreenContext'으로, 그리고 둘째, 디스플레이 스크린의 'MultiScreenContext'으로 변경된다면 상기 이벤트가 발생되어야 한다. 상기 두 경우에서, 소스 'MultiScreenContext'는 디스플레이 스크린이어야 한다.
'MULTI_SCREEN_CONTEXT_AUDIO_FOCUS_CHANGED' 필드(2002)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXTS_LAST' 필드(2022)는 'public static final int MULTI_SCREEN_CONTEXTS_LAST'로 선언되며, 'MultiScreenConfigurationEvent' 이벤트 식별자에 지정된 지난 이벤트 식별자이다.
'MULTI_SCREEN_CONTEXTS_LAST' 필드(2022)는 MSM I01 버전으로부터 적용된다.
도 20c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 생성자를 도시한다.
'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스(1714)의 생성자(2040)는 'MultiScreenContextEvent(java.lang.Object source, int id)'(2042)를 포함한다.
'MultiScreenContextEvent' 생성자(2042)는 'public MultiScreenContextEvent(java.lang.Object source, int id)'로 선언되며, 'MultiScreenContextEvent'(1714)를 생성한다.
'source' 파라미터는 'MultiScreenContext' 인터페이스에 대한 참조이다. 'id' 파라미터는 상기 이벤트의 이벤트 식별자이며, 그 값은 'MULTI_SCREEN_CONTEXT_DEVICES_CHANGED'(2006), 'MULTI_SCREEN_CONTEXT_DEVICES_Z_ORDER_CHANGED'(2008), 'MULTI_SCREEN_CONTEXT_SERVICE_CONTEXT_CHANGED'(2016), 'MULTI_SCREEN_CONTEXT_DISPLAY_SCREEN_CHANGED'(2012), 'MULTI_SCREEN_CONTEXT_DISPLAY_AREA_CHANGED'(2010), 'MULTI_SCREEN_CONTEXT_OUTPUT_PORT_CHANGED'(2014), 'MULTI_SCREEN_CONTEXT_VISIBILITY_CHANGED'(2018), 'MULTI_SCREEN_CONTEXT_Z_ORDER_CHANGED'(2020), 'MULTI_SCREEN_CONTEXT_AUDIO_SOURCES_CHANGED'(2004), 또는 'MULTI_SCREEN_CONTEXT_AUDIO_FOCUS_CHANGED'(2002) 중 하나이어야 한다.
'MultiScreenContextEvent' 생성자(2042)는 MSM I01 버전으로부터 적용된다.
도 20d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 메소드를 도시한다.
'org.ocap.ui.event.MultiScreenEvent' 클래스(1716)로부터 상속된 메소드(2052)는 'getId'를 포함하며, 'java.util.EventObject' 클래스로부터 상속된 메소드(2054)는 'getSource', 및 'toString' 중 적어도 하나를 포함한다. 'java.lang.Object' 클래스로부터 상속된 메소드(2056)는 'clone', 'equals', 'finalize', 'getClass', 'hashCode', 'notify', 'notifyAll', 'wait', 'wait' 및 'wait' 중 적어도 하나를 포함한다.
도 21a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextListener' 인터페이스의 정의를 도시한다.
'org.ocap.ui.event' 패키지의 'MultiScreenContextListener' 인터페이스(1702)는 슈퍼인터페이스로써 'java.util.EventListener'를 포함하며, 'public interface MultiScreenContextListener'로 선언되며, 'extends java.util.EventListener'로 확장된다.
'MultiScreenContextListener' 인터페이스(1702)는 시스템 및 어플리케이션이 발생시킨 'MultiScreenContext'의 변경에 대한 통지들을 제공하기 위해 사용된다.
'MultiScreenContextListener' 인터페이스(1702)는 MSM I01 버전으로부터 적용된다.
도 21b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextListener' 인터페이스의 메소드를 도시한다.
'org.ocap.ui.event.MultiScreenContextListener'(1702)의 메소드(2100)는 'void notify(MultiScreenContextEvent evt)'(2102)를 포함한다.
'notify(MultiScreenContextEvent)' 메소드(2012)는 'void notify(MultiScreenContextEvent evt)'로 선언된다. OCAP 구현이 'MultiScreenContext'을 변경하여 'MultiScreenContextEvent'가 발생한 때, 상기 구현은, 변경 정보가 리스너에게 보고되기 위해 모든 등록된 리스너들에 대해 'notify(MultiScreenContextEvent)' 메소드(2102)를 호출하여야 한다.
해당 리스너를 등록했던 어플리케이션에 대해 'MonitorAppPermission("multiscreen.context")'가 허용되지 않았고, 지정된 'MultiScreenContextEvent'와 연관된 소스 'MultiScreenContext'이 'ServiceContext'와 연관되지 않거나 상기 어플리케이션에 대해 억세스 가능하지 않은 'ServiceContext'와 연관된 경우, 'notify(MultiScreenContextEvent)' 메소드(2102)는 해당 리스너에 대해 호출되어서는 안 된다. 그러지 않으면 해당 리스너에 대해 호출되어야 한다.
'ServiceContext'가 'ServiceContextFactory.getServiceContexts()' 메소드로부터 반환된다면, 어플리케이션에 접근 가능하다.
'evt' 파라미터는 'MultiScreenContextEvent' 인스턴스이다.
'notify(MultiScreenContextEvent)' 메소드(2102)는 MSM I01 버전으로부터 적용된다.
도 22a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 클래스의 정의를 도시한다.
'org.ocap.ui.event.MultiScreenEvent'(1716)는 'java.lang.Object'의 하위 레벨인 'java.util.EventObject', 또 그 하위 레벨로 정의된다.
'org.ocap.ui.event.MultiScreenEvent'(1716)는 구현된 인터페이스로써 'java.io.Serializable'를 포함하며, 직접 알려진 서브클래스로써 'MultiScreenConfigurationEvent', 'MultiScreenContextEvent' 중 적어도 하나를 포함한다.
'org.ocap.ui.event.MultiScreenEvent'(1716)는 'public abstract class MultiScreenEvent'로 선언되며, 'extends java.util.EventObject'로 확장된다.
'MultiScreenEvent' 클래스는 멀티플 스크린 매니지먼트 기능성에 관련된 다른 종류의 타입들의 이벤트들에 의해 사용되는 이벤트 식별 코드들을 구성하기 위해 사용되는 추상적 기본 클래스이다.
'org.ocap.ui.event.MultiScreenEvent' 클래스(1716)는 MSM I01 버전으로부터 적용된다.
도 22b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 클래스의 필드를 도시한다.
'org.ocap.ui.event.MultiScreenEvent'(1716)의 필드(2200)는, 'static int MULTI_SCREEN_CONFIGURATION_FIRST'(2202) 및 'static int MULTI_SCREEN_CONTEXT_FIRST'(2204) 중 적어도 하나를 포함한다. 'java.util.EventObject' 클래스로부터 상속된 필드(2210)는 'source'를 포함한다.
'MULTI_SCREEN_CONFIGURATION_FIRST' 필드(2202)는 'public static final int MULTI_SCREEN_CONFIGURATION_FIRST'로 선언되며, 'MultiScreenConfigurationEvent' 이벤트 식별자들에 지정된 첫 번째 이벤트 식별자이다.
'MULTI_SCREEN_CONFIGURATION_FIRST' 필드(2202)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_CONTEXT_FIRST' 필드(2204)는 'public static final int MULTI_SCREEN_CONTEXT_FIRST'로 선언되며, 'MultiScreenContextEvent' 이벤트 식별자들에 지정된 첫 번째 이벤트 식별자이다.
'MULTI_SCREEN_CONTEXT_FIRST' 필드(2204)는 MSM I01 버전으로부터 적용된다.
도 22c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 클래스의 생성자를 도시한다.
'org.ocap.ui.event.MultiScreenEvent'(1716)의 생성자(2220)는, 'protected MultiScreenEvent(java.lang.Object source, int id)(2222)' 중 적어도 하나를 포함한다.
'MultiScreenEvent' 생성자(2222)는 'protected MultiScreenEvent(java.lang.Object source, int id)'로 선언되며, 'MultiScreenEvent'(1716)를 위한 보호된 생성자이다.
'source' 파라미터는 'MultiScreenEvent' 클래스의 구체적인 서브클래스에 의해 정의된 대로 이벤트 소스의 참조값이다.
'id' 파라미터는 'MultiScreenEvent'(1716)의 이벤트 식별자이다.
'MultiScreenEvent' 생성자(2222)는 MSM I01 버전으로부터 적용된다.
도 22d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 클래스의 메소드를 도시한다.
'org.ocap.ui.event.MultiScreenEvent'(1716)의 메소드(2230)는, 'int getId()'(2232)를 포함한다. 'java.util.EventObject' 클래스로부터 상속된 메소드(2240)는 'getSource' 및 'toString' 중 적어도 하나를 포함한다. 'java.lang.Object' 클래스로부터 상속된 메소드(2245)는 'clone', 'equals', 'finalize', 'getClass', 'hashCode', 'notify', 'notifyAll', 'wait', 'wait' 및 'wait' 중 적어도 하나를 포함한다.
'getId()' 메소드(2232)는 'public int getId()'로 선언되며, 'MultiScreenEvent'에 연관된 이벤트 식별자를 획득한다.
'MultiScreenEvent' 클래스의 서브클래스들, 즉 'MultiScreenConfigurationEvent' 및 'MultiScreenContextEvent',을 가리키는 'MultiScreenEvent'의 이벤트 식별자가 반환된다.
'getId()' 메소드(2232)는 MSM I01 버전으로부터 적용된다.
도 23a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스의 정의를 도시한다.
'org.ocap.ui.event.MultiScreenResourceEvent'(1718)는 'java.lang.Object'의 하위레벨인 'java.util.EventObject', 또 그 하위레벨로 정의된다.
'org.ocap.ui.event.MultiScreenResourceEvent'(1718)에 의해 구현된 인터페이스는 'java.io.Serializable'를 포함한다. 'org.ocap.ui.event.MultiScreenResourceEvent'(1718)는 'public class MultiScreenResourceEvent'로 선언되며, 'extends org.davic.resources.ResourceStatusEvent'로 확장된다.
'MultiScreenResourceEvent' 클래스(1718)는 멀티스크린 관련 리소스들의 리 소스 상태와 관련된 변경 사항을 보고하기 위해 사용된다.
'org.ocap.ui.event.MultiScreenResourceEvent'(1718)는 MSM I01 버전으로부터 적용된다.
도 23b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스의 필드를 도시한다.
'org.ocap.ui.event.MultiScreenResourceEvent' 클래스(1718)는 'static int MULTI_SCREEN_RESOURCE_SCREEN_RELEASED'(2302), 및 'static intMULTI_SCREEN_RESOURCE_SCREEN_RESERVED'(2304) 중 적어도 하나를 포함한다. 'java.util.EventObject' 클래스로부터 상속된 필드(2310)는 'Source'를 포함한다.
'MULTI_SCREEN_RESOURCE_SCREEN_RELEASED' 필드(2302)는 'public static final int MULTI_SCREEN_RESOURCE_SCREEN_RELEASED'로 선언되며, 스크린에 대한 예약 할당이 방금 해제되었으며, 상기 스크린( 또는 그 설정하는 스크린 디바이스들)이 현재 예약 할당될 수 있음(즉, 현재 예약 할당이 해제되었음)을 나타낸다.
'MULTI_SCREEN_RESOURCE_SCREEN_RELEASED' 필드(2302)는 MSM I01 버전으로부터 적용된다.
'MULTI_SCREEN_RESOURCE_SCREEN_RESERVED' 필드(2304)는 'public static final int MULTI_SCREEN_RESOURCE_SCREEN_RESERVED'로 선언되며, 스크린에 대한 예약 할당이 어플리케이션에 방금 허용되었으며, 상기 스크린(그 구성하는 스크린 디바이스들을 포함)가 더 이상 예약 할당이 해제된 상태가 아님을 나타낸다.
'MULTI_SCREEN_RESOURCE_SCREEN_RESERVED' 필드(2304)는 MSM I01 버전으로부 터 적용된다.
도 23c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스의 생성자를 도시한다.
'MultiScreenResourceEvent' 클래스(1718)의 생성자(2320)는 'MultiScreenResourceEvent(java.lang.Object source, int id)'(2322)를 포함한다.
'MultiScreenResourceEvent' 생성자(2322)는 'public MultiScreenResourceEvent(java.lang.Object source, int id)'로 선언되며, 'MultiScreenResourceEvent'(1718)를 위한 생성자이다.
'source' 파라미터는 그 리소스 상태가 변경된 'HScreen' 인스턴스에 대한 참조값이며, 'id' 파라미터는 'MultiScreenResourceEvent'(1718)의 이벤트 식별자이다.
'MultiScreenResourceEvent' 생성자(2322)는 MSM I01 버전으로부터 적용된다.
도 23d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스의 메소드를 도시한다.
'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스(1718)의 메소드(2330)는, 'int getId()'(2332) 및 'java.lang.Object getSource()'(2334) 중 적어도 하나를 포함한다. 'java.util.EventObject' 클래스로부터 상속된 메소드(2340)는 'toString'를 포함하고, 'java.lang.Object' 클래스로부터 상속된 메소드(2345)는 'clone', 'equals', 'finalize', 'getClass', 'hashCode', 'notify', 'notifyAll', 'wait', 'wait' 및 'wait' 중 적어도 하나를 포함한다.
'getSource()' 메소드(2334)는 'public java.lang.Object getSource()'로 선언되며, 상기 이벤트를 생성한 소스 객체를 획득한다.
상기 'getSource()' 메소드(2334)는 'org.davic.resources.ResourceStatusEvent' 클래스의 'getSource' 메소드를 재정의(override)한다. 상기 'getSource()' 메소드(2334)는 'HScreen' 인스턴스 또는 그의 서브클래스에 대한 참조값을 반환한다.
'getSource()' 메소드(2334)는 MSM I01 버전으로부터 적용된다.
'getId()' 메소드(2332)는 'public int getId()'로 선언되며, 'MultiScreenResourceEvent'(1718)와 연관된 리소스 이벤트 식별자를 획득한다.
'MULTI_SCREEN_RESOURCE_SCREEN_RELEASED(2302)', 'MULTI_SCREEN_RESOURCE_SCREEN_RESERVED'(2304) 중 하나의 식별자인 'MultiScreenResourceEvent'(1718)의 이벤트 식별자가 반환된다.
'getId()' 메소드(2332)는 MSM I01 버전으로부터 적용된다.
이하, 도 24a 내지 도 29 를 참고하여, 본 발명의 일 실시예에 따른 멀티스크린 설정을 위한 어플리케이션 사용 제한 조건이 상술된다.
본 발명의 일 실시예는, 멀티스크린 설정의 변경, 즉 재설정을 위해서 전제 조건(도 24a 내지 24c) 및 사후 조건(도 25a 내지 25e)이 만족되어야 한다. 이때 이하의 가정 하에서 전제 조건 및 사후 조건이 만족되어야 한다.
1. 플랫폼은 MSM가 정의된 대로 구현한다;
2. 둘 이상의 멀티스크린 설정이 존재하고 억세스 가능하다;
3. 호출자(caller)는 'MonitorAppPermission("multiscreen.configuration")'를 갖는다.
4. 'verifyConstraints()' 메소드에 의해 'setMultiScreenConfiguration()'가 호출된 직접적인 결과가 아니라, 'verifyConstraints()' 메소드가 실행되는 동안에는, 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 또는 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트가 생성되지 않는다 .
5. 'verifyConstraints()' 메소드가 실행되는 동안에는, 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_SCREEN_ADDED' 이벤트 또는 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_SCREEN_REMOVED' 이벤트가 생성되지 않는다.
6. 어플리케이션은 'allow_default_device_reconfig'를 멀티플 스크린 사용 기술자에서 '1'로 설정한다.
7. 플랫폼은 설정 변경 과정 동안 키 디폴트 스크린 디바이스 설정 파라미터들, 특히 스크린 영역, 픽셀 해상도 및 픽셀 가로세로비율를 보전한다. 즉, 디폴트 설정 디바이스 파라미터들을 재설정하기 위해 어플리케이션이 'allow_default_device_reconfig'을 '1'로 설정해놓았다는 사실은 이 경우 유효하지 않는다. (상기 확인 과정은 플랫폼이 이러한 파라미터들을 보전하지 않는 경우를 확인하는 경우까지 확장될 수 있다. 즉, 적합한 'HScreenConfigurationEvent' 또는 'MultiScreenContextEvent'가 보고될 수 있고 플랫폼이 이러한 파라미터들을 보전하지 않음을 확인하는데 사용될 수 있다.)
도 24a 내지 24c 는 본 발명의 일 실시예에 따른 멀티스크린 설정의 변경을 위한 전제 조건을 도시한다.
도 24a의 S 2410에서 상태 불변성이 확인된다. 일 실시예에서, 전제 조건으로 정적 상태 불변성이 확인된다. 여기서 상태 불변성을 확인하는 verifyInvariantConstraints() 메소드는 도 26a 내지 26d 를 참고하여 후술된다.
도 24a의 S 2420에서 디폴트 스크린이 기록된다.
도 24a의 S 2430에서 디폴트 백그라운 스크린 디바이스 및 키 설정 파라미터들이 기록된다.
도 24b의 S 2440에서 디폴트 비디오 스크린 디바이스 및 키 설정 파라미터들이 기록된다.
도 24b의 S 2450에서 디폴트 그래픽 스크린 디바이스 및 키 설정 파라미터들이 기록된다.
도 24c의 S 2460에서 넌-디폴트 스크린들이 기록된다.
도 24c의 S 2470에서 넌-디폴트 스크린 디바이스들이 기록된다.
도 24c의 S 2480에서 현재 멀티스크린 설정과 다른 멀티스크린 설정이 검색 된다.
도 24d 는 본 발명의 일 실시예에 따른 멀티스크린 설정의 변경 과정을 도시한다.
S 2490에서 멀티스크린 설정이 변경된다. 즉, 'MSM.setMultiScreenConfiguration'( 'MSC2', 'null' 값 )을 통해 멀티스크린 설정이 변경되며, 'waitForMultiScreenConfigurationChangingEvent()' 메소드, 'waitForMultiScreenConfigurationChangedEvent()' 메소드를 통해 'MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트 및 'MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트가 발생하길 대기한다.
도 25a 내지 25e 는 본 발명의 일 실시예에 따른 멀티스크린 설정의 변경을 위한 사후 조건을 도시한다.
도 25a의 S 2500 에서 불변성이 확인된다. 일 실시예에서, 사후 조건으로 정적 상태 불변성이 확인된다. 여기서 상태 불변성을 확인하는 'verifyInvariantConstraints()' 메소드는 도 26a 내지 26d 를 참고하여 후술된다.
도 25a의 S 2505 에서 현재 멀티스크린 설정이 새로운 설정이어야 한다.
도 25a의 S 2510 에서 새로운 디폴트 스크린이 기존 디폴트 스크린과 동일한 인스턴스이어야 한다.
도 25a의 S 2515 에서, 새로운 디폴트 백그라운 스크린 디바이스가 존재하고, 어플리케이션이 'allow_default_device_reconfig'을 '1'로 설정하여 재설정 후 디폴트 백그라운 디바이스가 이용 가능하지 않도록 된 경우가 아니라면, 새로운 디폴트 백그라운드 스크린 디바이스는 기존 디폴트 백그라운드 스크린 디바이스와 동일한 인스턴스임이어야 한다. 이 때 기존 백그라운드 스크린 디바이스는 빈 백그라운드 스크린 디바이스 상태로 재설정되어야 한다.
도 25b의 S 2520 에서, 새로운 디폴트 백그라운드 스크린 디바이스가 존재한다면, 새로운 디폴트 백그라운드 스크린 디바이스는 이전 디폴트 백그라운드 스크린 디바이스가 갖고 있던 동일한 스크린 영역, 픽셀 해상도, 및 픽셀 가로세로비율를 가져야 한다.
도 25c의 S 2525 에서, 새로운 디폴트 비디오 스크린 디바이스가 존재하고, 어플리케이션이 'allow_default_device_reconfig'을 '1'로 설정하여 재설정 후 디폴트 비디오 스크린 디바이스가 이용 가능하지 않도록 된 경우가 아니라면, 새로운 디폴트 비디오 스크린 디바이스는 기존 디폴트 비디오 스크린 디바이스와 동일한 인스턴스이어야 한다. 이 때 기존 비디오 스크린 디바이스는 빈 비디오 스크린 디바이스 상태로 재설정되어야 한다.
도 25c의 S 2530에서, 새로운 디폴트 비디오 스크린 디바이스가 존재한다면, 새로운 디폴트 비디오 스크린 디바이스는 이전 디폴트 비디오 스크린 디바이스가 갖고 있던 동일한 스크린 영역, 픽셀 해상도, 및 픽셀 가로세로비율를 가져야 한다.
도 25d의 S 2535에서, 새로운 디폴트 그래픽 스크린 디바이스가 존재하고, 어플리케이션이 'allow_default_device_reconfig'을 '1'로 설정하여 재설정 후 디폴트 그래픽 스크린 디바이스가 이용 가능하지 않도록 된 경우가 아니라면, 새로운 디폴트 그래픽 스크린 디바이스는 기존 디폴트 그래픽 스크린 디바이스와 동일한 인스턴스이어야 한다. 이 때 기존 그래픽 스크린 디바이스는 빈 그래픽 스크린 디바이스 상태로 재설정되어야 한다.
도 25d의 S 2540에서, 새로운 디폴트 그래픽 스크린 디바이스가 존재한다면, 새로운 디폴트 그래픽 스크린 디바이스는 이전 디폴트 그래픽 스크린 디바이스가 갖고 있던 동일한 스크린 영역, 픽셀 해상도, 및 픽셀 가로세로비율를 가져야 한다.
도 25e의 S 2545에서, 재설정 이전에 획득된 모든 넌-디폴트 스크린에 대해, 더 이상 넌-디폴트 스크린이 아니라면, 빈 스크린과 동일하여야 한다. 아직 넌-디폴트 스크린이라면, 빈 스크린과 동일해서는 안 된다.
도 25e의 S 2550에서, 재설정 이전에 획득된 모든 넌-디폴트 스크린 디바이스에 대해, 더 이상 넌-디폴트 스크린 디바이스가 아니라면, 빈 스크린 디바이스와 동일하여야 한다. 아직 넌-디폴트 스크린 디바이스라면, 빈 디바이스와 동일해서는 안 된다.
도 26a 내지 26d 는 본 발명의 일 실시예에 따른 상태 불변성을 확인하기 위한 조건을 도시한다.
도 26a의 S 2605에서, 멀티스크린 매니저가 있어야 한다.
도 26a의 S 2610에서, 현재 멀티스크린 설정이 있어야 한다.
도 26a의 S 2615에서, 억세스 가능한 멀티스크린 설정들의 비지 않은 세트가 있어야 한다.
도 26a의 S 2620에서, 현재 멀티스크린 설정은 억세스 가능한 설정이어야 한다.
도 26b의 S 2625에서, 현재 멀티스크린 설정 내의 스크린들의 비지 않은 세트가 있어야 한다.
도 26b의 S 2630에서, 현재 멀티스크린 설정 내의 스크린들은 비지 않아야 한다.
도 26b의 S 2635에서, 현재 멀티스크린 설정 내의 별개의 두 스크린은 동일한 리소스를 나타내서는 안 된다.
도 26c의 S 2640에서, 현재 디폴트 스크린이 있어야 한다.
도 26c의 S 2645에서, 현재 디폴트 스크린은 빈 스크린과 동일해서는 안 된다.
도 26c의 S 2650에서, 현재 멀티스크린 설정 내의 단 하나의 스크린 엔트리만이 디폴트 스크린과 동일한 리소스들을 나타내야 한다.
도 26c의 S 2655에서, 억세스 가능한 스크린들의 비지 않은 세트가 있어야 한다.
도 26c의 S 2660에서, 현재 디폴트 스크린이 억세스 가능한 스크린들의 세트의 별개의 멤버이어야 한다.
도 26d의 S 2665에서, 현재 디폴트 스크린의 백그라운 스크린 디바이스는 빈 백그라운 스크린 디바이스와 동일해서는 안 된다.
도 26d의 S 2670에서, 현재 디폴트 스크린의 비디오 스크린 디바이스는 빈 비디오 스크린 디바이스와 동일해서는 안 된다.
도 26d의 S 2675에서, 현재 디폴트 스크린의 그래픽 스크린 디바이스는 빈 그래픽 스크린 디바이스와 동일해서는 안 된다.
도 27 은 본 발명의 일 실시예에 따른 'getNonDefaultScreens()' 메소드의 정의를 도시한다.
'getNonDefaultScreens()' 메소드가 멀티스크린 설정(MSM) 상에서 디폴트 스크린이 아닌 스크린들(SX1ND)을 반환함으로써, 'getNonDefaultScreens()' 메소드에 의해 넌-디폴트 스크린이 획득된다.
도 28a 내지 28b 는 본 발명의 일 실시예에 따른 'getNonDefaultScreenDevices()' 메소드의 정의를 도시한다.
도 28a의 S 2810에서, 백그라운드 스크린 디바이스, 비디오 스크린 디바이스, 그래픽 스크린 디바이스 각각의 넌-디폴트 스크린 디바이스의 개수가 파악된다.
도 28b의 S 2820에서, 백그라운드 스크린 디바이스, 비디오 스크린 디바이스, 그래픽 스크린 디바이스 각각의 넌-디폴트 스크린 디바이스들이 획득되어 반환된다.
도 29 는 본 발명의 일 실시예에 따른 여러 메소드를 도시한다.
S 2910에서, 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGING' 이벤트가 발생되기까지 대기 상태가 유지된다.
S 2920에서, 'MultiScreenConfigurationEvent.MULTI_SCREEN_CONFIGURATION_CHANGED' 이벤트가 발생되기까지 대기 상태가 유지된다.
S 2930에서, 조건 확인 실패 여부가 체크되고 보고된다.
이하, 도 30a 내지 34c 를 참고하여 본 발명의 일 실시예가 OCAP 환경에서 구현되기 위해, 기존 OCAP 표준 규격으로부터 변경 또는 추가되는 사항들이 상술된다.
기존의 OCAP 어플리케이션은 'HAVi HScreen' 클래스에 의해 정의되는 기존 복수 개의 디스플레이 스크린 또는 로지컬 스크린들을 위한 스크린 매니지먼트, 특히, PIP 및 POP 기능의 스크린 매니지먼트를 지원하지 않거나, 매우 제한적으로 지원하고 있다. 따라서 본 발명의 OCAP 멀티플 스크린 매니저(OCAP MSM)을 구현하기 위해 어플리케이션은 'ocap.api.option.msm' 자바 시스템 프로퍼티의 존재 여부를 확인함하여야 한다.
'ocap.api.option.msm' 자바 시스템 프로퍼티가 확인되면, 어플리케이션은 PIP 기능, POP 기능, 멀티플 출력 기능, 및 메인 스크린, PIP 스크린, POP 스크린으로부터 출력 포트로의 맵핑 기능을 판별, 설정, 사용 또는 처리할 수 있게 된다.
도 30a 및 30b를 참고하여, 어플리케이션 식별을 위한 AppID 자바 타입이 OCAP MSM을 구현하기 위해 변경된 사항이 상술된다.
도 30a 은 OCAP 표준 규격의 AppID 자바 타입의 의사 코드(pseudo-code)를 도시하며, 도 30b 은 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'OcapAppID' 자바 타입의 의사 코드를 도시한다.
OCAP 플랫폼 구현이 복수 개의 서비스 컨텍스트들(javax.tv.selection.ServiceContext)을 동시 재생할 수 있다면, 기존의 'org.dvb.application.AppID' 클래스에 의해 표현되는 동일한 시스템 및 어플리케이션 식별자를 사용하는 어플리케이션의 두 인스턴스들이, 별개의 서비스 컨텍스트 상에서 처리하고 있더라도 서로 구별될 수 없다.
결과적으로, 기존 OCAP 플랫폼 구현은 동시 재생의 경우에, 어플리케이션 데이터베이스 및 'AppID' 클래스를 사용하는 관련 클래스들의 기능성은 충분히 정의될 수 없고 모호해진다.
본 발명의 일 실시예에 따르면, 도 30a의 S 3010이 도 30b의 S 3050으로 변경됨으로써 'AppID' 클래스 대신 새로이 도입되는 'OcapAppID' 클래스로 어플리케이션의 식별자가 정의된다.
마찬가지로, 도 30a의 S 3015, S 3020, S 3025, S 3030의 'AppID' 클래스 대신 각각 도 30b의 S 3055, S3060, S 3065, S 3070에서는 'OcapAppID' 클래스로 어플리케이션 식별자가 정의된다.
'OcapAppID' 클래스의 정의는 이하 도 31을 참고하여 상술된다.
도 31 은 본 발명의 일 실시예에 따른 'OcapAppID' 자바 타입을 지원하기 위한 의사 코드를 도시한다.
S 3110 에서 'OcapAppID'는 복수 개의 인스턴스들이 별개의 'ServiceContext' 인스턴스들과 연관되는 동일한 어플리케이션의 복수 개의 인스턴스들을 구별할 수 있게 한다.
여기서 '동일한' 어플리케이션이란 동일한 시스템 및 어플리케이션 식별자를 사용하는 어플리케이션을 의미한다. 동시에 재생되는 복수 개의 'ServiceContext' 인스턴스들을 지원하는 OCAP 구현은 동일한 어플리케이션의 동시에 발생되는 복수 개의 인스턴스들을 허용할 수 있다.
OCAP 어플리케이션에 의해 'AppID(int,int)' 생성자를 명시적으로 호출함으로써 'org.dvb.application.AppId'의 인스턴스가 생성되는 경우를 제외하면, 'AppID'의 모든 볼 수 있는 어플리케이션 인스턴스도 'OcapAppID'의 인스턴스이어야 한다.
OCAP 구현 또는 OCAP 어플리케이션이 'AppID'의 인스턴스를 접하고 'OcapAppID'의 인스턴스가 아닌 'id'로 'AppID'의 인스턴스를 지칭한다면, 상기 인스턴스는 시맨틱상 후술되는 대로 'OcapAppID'와 동일한 것으로 다루어져야 한다.
S 3120에서, 'OcapAppID' 클래스의 'ServiceContext' 필드를 디폴트화할 때 사용되기 위한 퍼블릭 생성자(Public constructor)가 정의된다. 특히, 상기 생성자를 호출하면, 'OcapAppID (oid, aid, 'null' 값)' 메소드를 호출하는 것과 동일한 효과가 발생한다.
'oid' 파라미터는 슈퍼클래스 생성자 'AppID(int oid, int aid)'의 동일한 이름이 주어진 파라미터와 호환성이 있는 구성 식별자이다.
'aid' 파라미터는 슈퍼클래스 생성자 'AppID(int oid, int aid)'의 동일한 이름이 주어진 파라미터와 호환성이 있는 구성 식별자이다.
S 3130에서, 'OcapAppID' 클래스의 'ServiceContext' 필드를 설명할 때 사 용되기 위한 퍼블릭 생성자(Public constructor)가 정의된다.
'oid' 파라미터는 슈퍼클래스 생성자 'AppID(int oid, int aid)'의 동일한 이름이 주어진 파라미터와 호환성이 있는 구성 식별자이다.
'aid' 파라미터는 슈퍼클래스 생성자 'AppID(int oid, int aid)'의 동일한 이름이 주어진 파라미터와 호환성이 있는 구성 식별자이다.
'context' 파라미터는 'ServiceContext' 인스턴스이거나 'null' 값이다. 'context' 파라미터가 'null' 값이라면 현재 어플리케이션의 현재 디폴트 'ServiceContext' 인스턴스는 상기 'ServiceContext' 인스턴스가 초기화될 때 'null' 값으로 변경되어야 한다.
S 3140에서, 'OcapAppID' 인스턴스와 연관된 'ServiceContext'가 획득된다. 'getServiceContext()' 메소드로 인해 'null' 값이 아닌 'ServiceContext' 인스턴스가 반환된다.
이하 도 32a 내지 34c 를 참고하여, 기존 OCAP 표준 규격의 'Hscene Manager'이 OCAP MSM 익스텐션을 지원할 수 있도록 변경된다.
기존의 'org.ocap.ui.HSceneManager'에 의해 정의된 '장면 매니지먼트(Scene management)' 기능성 및 관련 자바 타입들은 이하의 사용례들을 적절히 지원하지 못한다.
- 다른 인스턴스들이 각각 별개의 'HGraphicsDevice' 인스턴스들과 연관된 경우, 단일 어플리케이션에 의한 복수 개의 'Hscene' 인스턴스들의 사용;
- 모니터 어플리케이션 또는 권한을 가진 다른 어플리케이션이 현재 어플리 케이션과는 무관하게 한 'Hscene'로부터 또 다른 'Hscene'로 포커스를 옮기기 위한 기능;
- 모니터 어플리케이션 또는 권한을 가진 다른 어플리케이션이 어플리케이션 또는 플랫폼을 초기화하는 'Hscene' 포커스의 변경을 감시하고/하거나 변경/회피하기 위한 기능;
- 모니터 어플리케이션 또는 권한을 가진 다른 어플리케이션이, 현재 어플리케이션과는 무관하게 별개의 'HSceneBinding' 인스턴스들이 동일한 기저 장면 또는 다른 기저 장면을 지칭하고 있는 여부를 결정하기 위한 기능;
- 모니터 어플리케이션 또는 권한을 가진 다른 어플리케이션이, 가시성이 있는 모든 장면들(visible scenes), 상기 장면들의 'z-index'들 및 상기 장면들이 스크린 위치들의 정확한 상태 모델을 유지하는 능력;
- 장면들의 'z-index'에 대한 재설정 요청에 대한 반응으로써 장면들의 대체 'z-index'를 명시하는 능력;
- 'HSceneManager.getHSceneOrder()'의 반환 값 타입의 변경.
또한, 후술되는 기능성이 추가되어 'Hscene Management'가 재구성됨으로써 더 개선될 수 있다.
- 'HSceneBinding.getGraphicsDevice()' 메소드의 추가;
- 'HSceneBinding.getGraphicsDevice()' 메소드의 추가;
- 'HSceneChangeRequestHandler.testMoveFocus(HSceneBinding,HSceneBinding)' 메소 드의 추가;
- 'HSceneChangeRequestHandler.focusChanged(HSceneBinding,HSceneBinding)'의 추가;
- 'HSceneChangeRequestHandler.testShow(..)'의 제거;
- 'HSceneChangeRequestHandler.testOrder(..)' 메소드의 시그너처(signature), 반환 값 타입, 및 선언된 예외(declared exceptions)의 변경;
- 'HSceneChangeRequestHandler.testMove(..)'의 시그너처 및 예외 사항의 변경;
- 'HSceneManager.getAppDefaultHScene(AppID)' 메소드의 추가;
- 'HSceneManager.getAppHScenes(AppID)' 메소드의 추가;
- 'HSceneManager.getAppHSceneLocation(HScene)' 메소드의 추가;
- 'HSceneManager.getHSceneFocus()' 메소드의 추가;
- 'HSceneManager.getHSceneOrder(HGraphicsDevice)' 메소드의 추가;
- 'HSceneManager.transferHSceneFocus(HSceneBinding)' 메소드의 추가;
- 'HSceneManager.sameScene(HSceneBinding,HSceneBinding)' 메소드의 추가;
- 'HSceneManager.getHSceneOrder()' 메소드의 반환 값 타입 변경.
또한, 'HSceneManager' 인터페이스, 'HSceneBinding' 인터페이스, 및 'HSceneChangeRequestHandler' 인터페이스 및 상기 인터페이스들의 이전 구성요소 들의 개념이 명확해진다.
'javax.tv.graphics.TVContainer'에 있어서, OCAP 어플리케이션에 의해 (또는 OCAP 어플리케이션을 대표하여) 'getRootContainer(XletContext ctx)'가 호출되고, 'ctx' 파라미터는 상기 메소드를 호출하는 어플리케이션의 초기 'XletContext' 자바 타입이며, 소정 인스턴스가 반환되면, 상기 반환된 인스턴스는 'org.havi.ui.HSceneFactory.getDefaultHScene()'에 의해 동시에 반환될 인스턴스와 동일하여야 한다.
OCAP은 후술되는 특정 'OCAP Scene Management' 기능성이 추가됨으로써 DVB-GEM 1.0.2이 확장된다. 특히, 'org.ocap.ui.HSceneBinding' 자바 타입, 'org.ocap.ui.HSceneChangeRequestHandler' 자바 타입, 및 'org.ocap.ui.HSceneManager' 자바 타입과 이하 도 32b, 33b, 34b 및 34c 를 참고로 후술될 상기 자바 타입들의 관련 시맨틱을 구현하여야 한다.
또한, 'org.havi.ui.HSceneFactory'에 있어서, 이전에 획득된 'HScene' 인스턴스(S1) 및 획득될 또 다른 'HScene' 인스턴스(S2)가 다른 'HGraphicsDevice' 인스턴스들과 연관되지 않는다면, OCAP 어플리케이션이 상기 'HScene' 인스턴스(S2)를 획득하기 전에 상기 'HScene' 인스턴스(S1)에 대해 'dispose(HScene)' 메소드를 사용할 필요가 없다.
'포커스 핸들링 규칙(Focus Handling Rules)' 에 있어서, 구현은 포커스가 지정될 수 있는 'HScene' 인스턴스들(focusable Hscene instances)의 정렬된 총 목록을 유지하여야 한다. 포커스가 지정될 수 있는 'HScene'은 가시성의 활성 'HScene'이며, 이 경우, 'HScene.isVisible()' 메소드는 '참' 값을 반환하고, (ⅰ) 'HScene.setActive(boolean)' 메소드가 상기 어플리케이션에 의해 호출된 적이 없거나, (ⅱ) 'HScene.setActive(boolean focus)' 메소드가 '거짓'값의 'focus'에 대해 마지막으로 호출된 후 '참' 값과 동일한 상기 'focus' 파라미터에 대해 적어도 한번 호출된 적이 있다면 'HScene'은 활성화된 것으로 간주된다.
포커스가 결정된 'HScene'(focused HScene)는 지정된 입력 포커스인 포커스가 지정될 수 있는 'HScene'이다. 활성화된 'HGraphicsDevice' 인스턴스들 또는 'HScreen instances'의 개수와 상관 없이, 항상 포커스가 지정된 'HScene' 는 단 하나만이 존재한다.
'HScene'가 포커스를 지정할 수 있는 상태가 된다면, 상기 'HScene'는 포커스를 지정할 수 있는 'HScene' 목록의 마지막에 추가된다.
포커스를 지정할 수 있는 'HScene'에 포커스가 지정된다면, 상기 'HScene'는 포커스를 지정할 수 있는 'HScene' 목록의 시작 부분으로 옮겨진다.
'HScene' 인스턴스가 더 이상 포커스를 지정할 수 없다면, 상기 'HScene'는 포커스를 지정할 수 있는 'HScene' 목록으로부터 제거되어야 한다.
포커스가 지정된 'HScene'이 더 이상 포커스를 지정할 수 없다면, 구현은 상기 포커스가 지정된 'HScene'로부터 포커스를 철회하여야 하고, 상기 포커스를 지정할 수 있는 'HScene' 목록 상의 첫 번째 포커스를 지정할 수 있는 'HScene'로 입력 포커스를 지정하여야 한다.
첫 번재 포커스를 지정할 수 있는 'HScene'이 포커스를 지정할 수 있는 'HScene' 목록 상에 추가된경우, 구현은 자동적으로 상기 목록에 지정되어서는 안된다.
도 32a 은 OCAP 표준 규격의 'HSceneBinding' 자바 타입의 의사 코드를 도시하며, 도 32b 은 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'HSceneBinding' 자바 타입의 의사 코드를 도시한다.
도 32b의 S 3250에서, 도 32a의 기존 OCAP 규격에는 없는 'HGraphicsDevice' 인터페이스가 선언되는 과정이 추가된다.
도 32b의 S 3260에서, 다른 어플리케이션이 차지하여 'HScene' 참조로의 직접적인 억세스가 허용되지 않은 경우, 상기 'HScene'의 소정 특성들을 나타내는 수단을 제공하기 위해, 플랫폼을 정의하는 클래스에 의해 'HSceneBinding' 인터페이스가 구현된다.
도 32b의 S 3270에서, 'getGraphicsDevice()' 메소드가 매칭되는 'HScreen' 인스턴스의 정규화된 좌표 공간 상에서 현재 'HSceneBinding' 인터페이스가 가리키는 'HScreen' 인스턴스의 스크린 구형이 획득(반환)된다.
도 32b의 S 3280에서, 현재 'HSceneBinding' 인터페이스가 가리키는 'HScreen' 인스턴스가 연관되는 어플리케이션 속성이 획득(반환)된다
도 32b의 S 3290에서, 현재 'HSceneBinding' 인터페이스가 가리키는 'HScreen' 인스턴스가 연관되는 그래픽 디바이스가 획득(반환)된다.
도 33a 는 OCAP 표준 규격의 'HSceneChangeRequestHandler' 자바 타입의 의사 코드를 도시하며, 도 33b 는 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'HSceneChangeRequestHandler' 자바 타입의 의사 코드를 도시한다.
도 33a의 S 3310 은 제거된다.
도 33b의 S 3330에서, (ⅰ) 현재 재생되고 있지 않은 'HScene'의 추가, (ⅱ) 현재 재생되고 있는 'HScene'의 제거, (ⅲ) 스크린 상의 'HScene'의 위치 변경 (ⅳ) 'HGraphicsDevice'의 'HScene z-order' 상에서 'HScene'의 이동, (ⅴ) 'HScene'이 구성하는 계층 구조 사이의 AWT(Abstract Window Toolkit) 포커스의 이동, 및 (ⅵ) 'HScene'이 구성하는 계층 구조에 대한 AWT 포커스의 지정을 변경하는 통지 등의 작동 발생에 대한 요청을 다루기 위해 'HSceneChangeRequestHandler' 인터페이스가 권한을 가진 어플리케이션에 의해 구현된다.
도 33b의 S 3340에서, 'HScene'의 이동 (또는 사이즈 변경) 요청이 허용될지 여부가 시험된다. 'HScene'가 'HScreen' 상에서 이동되거나 크기가 조정되기 위한 경우, 즉 재생된 'HScene'의 'HScreenRectangle'의 위치 또는 크기가 변경되는 경우, testMove(HSceneBinding move, HSceneBinding currentScenes[]) 메소드가 호출된다.
'move' 파라미터는 영향 받는 'HScene'의 스크린 구형을 지명하는 'HSceneBinding'이며, 여기서 'HScene' 인스턴스는 'currentScenes'의 엔트리가 되어야 한다. 'currentScenes'는 영향 받는 'HScene'를 포함하여 현존 가시성이 있는 'HScene'들 (및 그들의 현재 스크린 구형들)에 과련된 'HSceneBinding'이다. 현재 컨텍스트에서, 'HScene.isVisible()' 메소드가 '참' 값을 반환하면 'HScene'는 가시성이 있는 것으로 간주된다.
testMove 메소드에 의해 'HScene'이 이동될 수 있다면 '참' 값이 반환되고, 그렇지 않다면 '거짓' 값이 반환된다.
도 33b에서 S 3350에서, 'HScene'의 'z-order' 변경이 요청될 수 있는지 여부가 시험된다. 'HScene'가 'z-order' 상에서 이동되거나, 'z-order'로 추가되거나 'z-order'로부터 제거될 때 'testOrder ( HSceneBinding reorder, HSceneBinding currentScenes[], int currentOrder, int newOrder )'가 호출된다. 'HScene'이 'z-order'로부터 제거되고 있는 경우(예를 들어 어플리케이션이 종료되고 있기 때문에 상기 어플리케이션의 'HScene'이 제거되고 있는 경우), 'testOrder' 메소드의 결과 값은 OCAP 구현에 의해 무시될 수 있다.
'testOrder' 메소드가 호출될 때 후술되는 제한 조건이 만족되어야 한다.
- 'currentOrder' 및 'newOrder' 중 적어도 하나는 음수가 아님;
- 'currentOrder'가 음수가 아니라면, 'currentOrder'는 'currentScenes'에 의해 참조되는 어레이의 유효 인덱스이다.
- 'currentOrder'가 'currentScenes'의 유효 인덱스이고, 'newOrder'가 음수가 아니라면, 'currentOrder'는 'currentScenes'에 의해 참조되는 어레이의 유효 인덱스이다.
'reorder' 파라미터는 영향 받는 'HScene'을 지명하는 'HSceneBinding'이다. 상기 'HScene'가 이미 'HScene z-order'상에 존재한다면 'currentScenes'의 인덱스로써 나타나야 한다. 그렇지 않으면, 상기 'HScene'가 'currentScenes' 상에 존재해서는 안 된다. 'reorder' 파라미터는 도 33a의 S 3320의 'testOrder' 메소드에는 고려되지 않는 파라미터로써, 'reorder' 파라미터에 의해 도 33b의 S 3350의 'testOrder' 메소드에 의해 영향 받는 'HScene'를 고려하며 'z-order'가 확인될 수 있다.
'currentScenes' 파라미터는 'z-order' 상에서 첫번째 엔트리(0)가 되어 가장 앞쪽 'HScene'이 되고, 가시성이 있는 현존 'HScene'에 해당하는 'HSceneBinding'이다. 해당 컨텍스트에서, 'HScene.isVisible()' 메소드가 '참'값을 반환한다면 'HScene' 인스턴스는 가시성이 있다고 간주된다.
'HScene.show()' 메소드 또는 'HScene.setVisible(true)' 메소드의 호출 때문에 'HScene'이 보여질 수 있다면, 'currentOrder' 파라미터는 그 값이 '-1' 값이다. 'HScene'가 이미 재생되었다면, 'currentOrder' 파라미터는, 이동될 'HScene'의 'currentScene' 어레이 상의 기존 위치를 나타내는 음이 아닌 정수이다.
'newOrder' 파라미터는, 영향받는 'HScene'이 이동될 새로운 위치를 가리키는 음이 아닌 정수이다. 'HScene'의 'z-order'로부터 (완전히) 제거된다면, 'newOrder' 파라미터는 값이 '-1' 값이다. 영향받는 'HScene'이 'HScene'의 'z-order'에 추가된다면, 'newOrder'는 한 자리 씩 아래로 이동될 모든 다른 현재 'HScene'과 함께 표시될 위치를 가리킨다. 'currentOrder'가 '-1' 값이고, 'newOrder'의 값이 'currentScenes'의 지난 유효 인덱스의 인덱스보다 크다면, 추가될 'HScene'는 'HScene'의 'z-order' 사에서 가장 뒷 쪽에 배치되도록 요청되어야 한다.
재정렬(추가/제거) 요청이 상기 파라미터들에 대해 설명된대로 허용된다면, 'testOrder' 메소드는 'null' 값을 반환한다. 상기 요청이 전술된 대로 수행되지 않는다면 'currentScenes' 파라미터 값이 반환된다.
(ⅰ) 'currentOrder' 값이 음이 아니고 'newOrder' 값이 음이라면 'currentScenes'의 값에서 'reorder'의 값을 뺀 값, (ⅱ) 'currentOrder' 값이 음이고 'newOrder' 값이 음이 아니라면, 'currentScenes'의 값과 'reorder'의 값의 합, 또는 (ⅲ) 'currentOrder' 값과 'newOrder' 값이 음이 아니라면, 'currentScenes'의 값을 포함하는 집합, 즉 (ⅰ), (ⅱ), (ⅲ)의 값들로 구성된 집합의 순열(permutation)인 'HSceneBinding' 인스턴스의 새로운 어레이가 반환된다.
도 33b의 S 3360에서, 'HScene'의 재지정 또는 'HScene'으로부터의 제거의 허용 여부가 확인된다. 'HSceneChangeRequestHandler' 자바 타입이 등록된다면, AWT 포커스가 'HScene' 계층 구조에 최초로 지정되거나, 'HScene' 계층 구조들 사이에서 이동되거나, 모든 'HScene' 계층 구조들로부터 제거될 때마다, 모두 OCAP 플랫폼 구현은 'testFocusChange' 메소드를 호출하여야 한다. 'testFocusChange' 메소드가 일부 포커스 상태 변화에 대해 '거짓' 값을 반환한다면, OCAP 플랫폼 구현은 상기 변경들을 완료해서는 안 되며, AWT 포커스를 변경되지 않은 채로 유지하여야 한다.
'HScene' 계층 구조의 하위 구성 사이 또는 'HScene' 인스턴스 내의 구성 요소들 사이에서 포커스가 이동되는 경우, OCAP 플랫폼 구현은 'testFocusChange' 메소드를 호출해서는 안 된다.
플랫폼을 개시한 AWT 'HScene' 포커스가 재지정되는 경우,OCAP 플랫폼 구현 은 'testFocusChange' 메소드를 호출할 수 있지만, 반드시 호출할 필요는 없다. 마찬가지로, OCAP 플랫폼 구현이 'testFocusChange' 메소드로부터 반환된 값을 사용할 수는 있으나, 반드시 사용할 필요는 없다. 그러나, 이런 경우, 플랫폼을 개시하는 'HScene' 포커스 변경의 통지를 제공하기 위해 플랫폼은 모든 경우에 'focusChanged(..)' 메소드를 호출하여야 한다.
'testFocusChange' 메소드가 호출될 때, 전제 조건으로써 'newScene' 또는 'oldScene' 중 하나(또는 모두)는 'null' 값이 아니어야 한다.
'newScene' 파라미터는, 포커스가 지정될 'HScene'를 나타내는 'HSceneBinding'이다. 포커스가 어떤 'HScene'에 지정되지 않을 경우, 즉 포커스가 지정되지 않은 경우로 방치될 때, 'newScene' 파라미터는 'null' 값이다.
'oldScene' 파라미터는 포커스가 제거될 'HScene'를 나타내는 'HSceneBinding' 자바 타입이다. ('testFocusChange' 메소드가 호출되기 직전에) 포커스가 어떤 'HScene'에 지정되지 않은 경우, 'oldScene' 파라미터는 'null' 값이다.
포커스의 이동 (또는 제거)가 발생될 수 있다면 'testFocusChange' 메소드는 '참' 값을 반환한다. 그렇지 않으면 '거짓'값이 반환된다.
도 33b의 S 3370에서, AWT 포커스의 현재 지정에서의 변경의 조정기(handler)가 통지된다. 'focusChanged' 메소드는 일부 'HScene'으로의 AWT 포커스의 현재 지정으로의 변경의 통지를 제공한다. 이러한 'HScene'를 지명하기 위해, 'HSceneBinding'이 사용되고, 이 경우 'HSceneBinding.getAppAttributes()' 메소드로부터 식별된 어플리케이션의 조합을 통해 장면이 고유하게 식별되고, 'HSceneBinding.getGraphicsDevice()' 메소드로부터 그래픽 스크린 디바이스를 고유하게 식별된다.
'HScene' 계층 구조의 하위 구성 사이 또는 'HScene' 인스턴스 내의 컴포넌트들 사이에서 포커스가 이동되는 경우, OCAP 플랫폼 구현은 'focusChanged' 메소드를 호출해서는 안 된다.
전술된 고유 식별성은 주어진 어플리케이션은 'HGraphicsDevice' 당 하나 이상의 'HScene'을 구비하지 않는다는 제한 조건에 기초한다.
'newScene' 파라미터는 (ⅰ) 포커스가 지정된 새로운 'HScene'를 간접적으로 가리키는 'HSceneBinding' 자바 타입이거나, (ⅱ) (현재 어플리케이션 환경에서) 어떤 'HScene'에도 현재 포커스가 지정되지 않음을 나타내는 'null' 값이다.
'oldScene' 파라미터는, (ⅰ) 포커스가 제거된 구(이전) 'HScene'를 간접적으로 가리키는 'HSceneBinding' 자바 타입이거나, (ⅱ) (현재 어플리케이션 환경에서) 이전에 포커스가 지정된 'HScene'가 없음을 나타내는 'null' 값이다.
도 34a 는 OCAP 표준 규격의 'HSceneManager' 자바 타입의 의사 코드를 도시하고, 도 34b 및 34c 는 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'HSceneManager' 자바 타입의 의사 코드를 도시한다.
도 34b의 S 3420에서, 'HSceneManager' 클래스는, 권한을 가진 어플리케이션이 'HScene'의 요청된 변경을 처리하는 조정기(handler)를 등록하도록 허용하는 플랫폼 매니저 컴포넌트를 나타낸다. 이때, 'HScene'는 ('HGraphicsDevice'의) 모든 'HScene'들과 합성된 'HGraphicsDevice' 내에서 변경된다. 또한, 'HScene'의 'z-order', 디폴트 장면, 현재 포커스 지정은 'HSceneManager' 클래스를 사용하면서 조회될 수 있다.
도 34b의 S 3430에서, 보호된 디폴트 생성자가 생성된다.
도 34b의 S 3435에서, 'HSceneManager' 클래스의 싱글턴 인스턴스가 획득되며, 이 경우 획득된 인스턴스는 (호출 어플리케이션이 아닌) 플랫폼으로 (억세스 가능한 상태 관점으로부터) 한정된 것처럼 다루어진다. 'HSceneManager'가 반환된다.
도 34b의 S 3440에서, 'setHSceneChangeRequestHandler(HSceneChangeRequestHandler handler)' 메소드는 어플리케이션이 어플리케이션 자체를 'HScene' 변경 요청 조정기로 설정하도록 허용한다. 'setHSceneChangeRequestHandler' 메소드가 호출된 때 조정기가 이미 등록된 경우, 상기 조정기는 소정 다른 조정기로 대체된다.
'handler' 파라미터는 (ⅰ) 디폴트 포커스 지정에 대한 변경들 뿐만 아니라 'HScene'의 'z-order'으로의 변경에 대해 조회될 'HSceneChangeRequestHandler'이거나, (ⅱ) 현재 조정기가 제거된 경우, 'null' 값이다.
호출자(caller)에 'MonitorAppPermission("handler.resource")'가 허용되지 못한 경우 'SecurityException'가 발생된다.
도 34b의 S 3445에서, 호출 어플리케이션의 디폴트 'HGraphicsDevice'의 가시성 있는 'HScene'들과 관련 있는 장면 바인딩들(scene bindings)이 획득된다. 도 34a의 S 3410의 'public static OcapAppAttributes [] getHSceneOrder()'과 비교해보면, 'static OcapAppAttributes []' 타입 대신 'HSceneBinding[]' 타입으로 선언되어 장면 바인딩들(scene bindings)이 반환된다.
호출 어플리케이션에 디폴트 그래픽 스크린이 지정된다면, 'getHSceneOrder()' 메소드는 'getHSceneOrder(HScreen.getDefaultHScreen().getDefaultHGraphicsDevice())' 메소드와 동일한 값을 반환하여야 한다. 그렇지 않으면, 빈 어레이가 반환되어야 한다.
'z-order' 상에서 호출 어플리케이션의 디폴트 'HGraphicsDevice'의 가시성 있는 'HScene' 인스턴스들에 해당하는 'HSceneBinding' 인스턴스들의 어레이가 반환된다. 여기서 '가시성 있다'는 표현은 'scene.isVisible()' 메소드가 '참' 값을 반환한다는 의미로 사용된다.
호출자에게 'MonitorAppPermission("handler.resource")'가 허가되지 않는다면, 'SecurityException'가 발생된다.
도 34b의 S 3450에서, 특정 'HGraphicsDevice'의 가시성 있는 'HScene'에 해당하는 장면 바인딩들이 획득된다.
반환된 장면 바인딩들의 어레이는, 첫 번째 엔트리(0)가 특정 'HGraphicsDevice'에 대한 'HScene'의 'z-order' 상에서 가장 앞쪽의 가시성 있는 'HScene'에 해당하도록 하고, 마지막 엔트리는 가장 뒤쪽의 가시성 있는 'HScene'에 해당하도록 정렬된다.
특정 그래픽 디바이스가 디스플레이 스크린 또는 출력 포트와 연관되지 않은 스크린과 연관되거나, 출력 포트 상에서 재생될 수 없다면, 빈 어레이가 반환되어야 한다.
'device' 파라미터는 'HGraphicsDevice' 자바 타입이다.
'z-order' 상으로 특정 'HGraphicsDevice'의 가시성 있는 'HScene' 인스턴스들에 해당하는 'HSceneBinding' 인스턴스들의 어레이가 반환된다. 여기서, '가시성 있다'는 표현은 'scene.isVisible()' 메소드가 '참' 값을 반환한다는 의미로 사용된다.
호출자에게 'MonitorAppPermission("handler.resource")'가 허가되지 않는다면, 'SecurityException'가 발생된다.
도 34c의 S 3455에서, 호출 어플리케이션의 디폴트 'HScene'을 위한 'HScene'의 'z-order'이 획득된다. 어플리케이션은 'HGraphicsDevice' 인스턴스의 'z-order' 상에서의 디폴트 'HScene'의 위치를 결정하기 위해 'getAppHSceneLocation()' 메소드을 호출할 수 있다.
(어플리케이션이 유저 인터페이스를 갖지 않은 경우를 포함하여) 어플리케이션이 디폴트 'HScene'에 대한 참조를 획득하지 않았다면, 'getAppHSceneLocation()' 메소드는 '-1' 값을 반환한다. 그렇지 않으면, 'getAppHSceneLocation(HSceneFactory.getDefaultHScene())' 메소드와 동일한 값이 반환된다.
도 34c의 S 3460에서, 특정 'HScene'을 위한 'HScene'의 'z-order' 위치가 획득된다. 어플리케이션들은 'HGraphicsDevice'의 'z-order' 상에서의 소정 'HScene'의 위치를 결정하기 위해 'getAppHSceneLocation(HScene scene)' 메소드를 호출할 수 있다.
'scene' 파라미터는, 'HScene'이 연관된 'HGraphicsDevice' 인스턴스 내의 'z-order' 위치를 얻기 위한 'HScene' 인스턴스이다.
'getAppHSceneLocation(HScene scene)' 메소드는, 소정 'HScene'을 위한 'HScene'의 'z-order' 위치를 가리키는 정수형의 값을 반환된다. 여기서 반환되는 값은 'z-order' 상에서 증가하는 순서로 정렬되고, 0이 가장 앞쪽이고 나머지 모든 값들은 가장 앞쪽 'HScene'보다 아래로 증가하는 방향이다. 'HScene'이 정렬되지 않았거나, 가시성이 없으면 '-1' 값이 반환된다. 여기서 '가시성이 있는 경우'는 'scene.isVisible()' 메소드가 '참'값을 반환하는 경우에 해당한다.
도 34c의 S 3465에서, 어플리케이션이 디폴트 'HScene'을 구비한다면, 'getAppDefaultHScene(AppID id)' 메소드는 식별된 어플리케이션의 디폴트 'HScene'의 결정을 허용하는 'HSceneBinding'을 획득된다.
'getAppDefaultHScene(AppID id)' 메소드가 호출된다면, 디폴트 'HScene'의 생성되거나 디폴트 'HScene'과 상기 어플리케이션이 연관되어서는 안된다.
'id' 파라미터는 OCAP 어플리케이션을 나타내는 'AppID' 인스턴스이다.
'getAppDefaultHScene(AppID id)' 메소드는, (ⅰ) 식별된 어플리케이션에 지정된 디폴트 'HScene'를 (간접적으로) 나타내는 'HSceneBinding', 또는 (ⅱ) 현재 어플리케이션이 어플리케이션 데이터베이스 상에 더 이상 존재하지 않거나, 종료되 었거나, 현재 디폴트 'HScene'이 지정되지 않음을 나타내는 'null' 값을 반환한다.
호출자에게 'MonitorAppPermission("handler.resource")'가 허가되지 않는다면, 'SecurityException'가 발생된다.
도 34c의 S 3470에서, 식별된 어플리케이션의 현재 'HScene' 인트턴스들을 나타내는 'HSceneBinding' 인스턴스들의 어레이가 'getAppHScenes(AppID id)' 메소드에 통해 획득된다.
'getAppHScenes(AppID id)' 메소드의 호출이 'HScene'의 생성 또는 'HScene'과 어플리케이션의 연관 관계를 초래해서는 안 된다.
파라미터 'id'는 OCAP 어플리케이션을 가리키는 'AppID' 인스턴스이다.
'getAppHScenes(AppID id)' 메소드에 의해, (ⅰ) 식별된 어플리케이션에 지정된 'HScene' 인스턴스들을 (간접적으로) 가리키는 'HSceneBinding' 인스턴스들의 비지 않은 어레이이거나, (ⅱ) 현재 어플리케이션이 어플리케이션 데이터베이스에 더 이상 존재하지 않거나, 종료되었거나, (현재) 어떤 'HScene'도 지정되지 않음을 나타내는 'null' 값이 반환되어야 한다.
호출자에게 'MonitorAppPermission("handler.resource")'가 허가되지 않는다면, 'SecurityException'가 발생된다.
도 34c의 S 3475에서, 'getHSceneFocus()' 메소드를 통해, AWT 포커스가 지정된 (현재 어플리케이션 환경의) 'HScene'를 결정하는 것을 허용하는 'HSceneBinding'가 획득된다.
호출 어플리케이션에 MonitorAppPermission("handler.resource")가 허가되지 않은 경우, AWT 포커스가 어플리케이션이 구비하지 않은 'HScene' 에 지정되었다면 'getHSceneFocus()' 메소드는 'null' 값을 반환하여야 한다.
'getHSceneFocus()' 메소드를 통해, (ⅰ) AWT 포커스가 지정되지 않은 'HScene'를 (간접적으로) 나타내는 'HSceneBinding', 또는 (ⅱ) (현재 어플리케이션 환경에서) AWT 포커스가 어떤 'HScene'에도 지정되지 않았거나, 전술된 환경에서 호출 어플리케이션에 'MonitorAppPermission("handler.resource")'가 허가되지 않았음을 나타내는 'null' 값이 반환되어야 한다.
도 34c의 S 3480에서, 'transferHSceneFocus(HSceneBinding binding)' 메소드를 통해, (현재 어플리케이션 환경의) 특정 'HScene'으로 AWT 포커스가 전송되도록 요청되거나, 특정 'HScene'으로부터 AWT 포커스가 제거되도록 요청된다.
이러한 전송(또는 제거) 요청이 완수된다면, 상기 요청의 완수는 'transferHSceneFocus' 메소드의 호출에 대해 비동기적일 수 있다. 더욱이, 상기 플랫폼의 상태, 아니면 일부 다른 조건이 AWT 포커스의 변경을 방해한다면 상기 요청은 완수되지 않을 수도 있다.
동작 상태에 있지 않은 어플리케이션 또는 포커스가 지정될 수 없는 'HScene'에 AWT 포커스를 지정하는 요청은 완수되어서는 안 된다.
'transferHSceneFocus' 메소드 또는 (메소드와 독립적으로) 상기 플랫폼에 의해 일부 'HScene'으로 포커스가 성공적으로 이동( 또는 제거)된 경우, 'focusChanged()' 메소드는 등록된 'HSceneChangeRequestHandler' 인스턴스에 대해 호출되어서는 안 된다.
'binding' 파라미터는, (ⅰ) AWT 포커스 지정이 요청된 'HScene'를 고유하게 식별하는 'HSceneBinding' 인터페이스, 또는 (ⅱ) (현재 어플리케이션 환경의) 모든 'HScene' 인스턴스들로부터 삭제되도록 요청받은 AWT 포커스 지정을 나타내는 'null' 값이다.
호출자에게 'MonitorAppPermission("handler.resource")'가 허가되지 않는다면, 'SecurityException'가 발생된다.
도 34c의 S 3485에서, '( HSceneBinding sb1, HSceneBinding sb2 )' 메소드를 통해, 두 'HSceneBinding' 인스턴스가 동일한 기저 장면을 가리키는지 여부가 결정된다.
'sb1' 파라미터 및 'sb2' 파라미터는 'HSceneBinding' 인스턴스이다.
'sb1' 및 'sb2'가 동일한 기저 장면을 가리킨다면 '( HSceneBinding sb1, HSceneBinding sb2 )' 메소드는 '참' 값을 반환하고, 그렇지 않으면 '거짓' 값이 반환된다.
한편, 상술한 본 발명의 실시예들은 컴퓨터에서 실행될 수 있는 프로그램으로 작성가능하고, 컴퓨터로 읽을 수 있는 기록매체를 이용하여 상기 프로그램을 동작시키는 범용 디지털 컴퓨터에서 구현될 수 있다. 상기 컴퓨터로 읽을 수 있는 기록매체는 마그네틱 저장매체(예를 들면, 롬, 플로피 디스크, 하드디스크 등), 광학적 판독 매체(예를 들면, 시디롬, 디브이디 등) 및 캐리어 웨이브(예를 들면, 인터넷을 통한 전송)와 같은 저장매체를 포함한다.
이제까지 본 발명에 대하여 그 바람직한 실시예들을 중심으로 살펴보았다. 본 발명이 속하는 기술 분야에서 통상의 지식을 가진 자는 본 발명이 본 발명의 본질적인 특성에서 벗어나지 않는 범위에서 변형된 형태로 구현될 수 있음을 이해할 수 있을 것이다. 그러므로 개시된 실시예들은 한정적인 관점이 아니라 설명적인 관점에서 고려되어야 한다. 본 발명의 범위는 전술한 설명이 아니라 특허청구범위에 나타나 있으며, 그와 동등한 범위 내에 있는 모든 차이점은 본 발명에 포함된 것으로 해석되어야 할 것이다.
도 1 은 종래 기술에 따라 PiP 방식으로 구현된 화면 구성 형태를 도시한다.
도 2 는 본 발명의 일 실시예에 따른 로지컬 스크린, 디스플레이 스크린 및 디스플레이 맵퍼의 관계를 도시한다.
도 3 은 본 발명의 일 실시예에 따른 멀티스크린 매니저를 구현할 수 있는 디지털 TV 시스템의 블록도를 도시한다.
도 4 는 본 발명의 일 실시예를 구현하는 디지털 TV 시스템에서 여러 컨텐츠를 재생하는 일례를 도시한다.
도 5a 및 5b 는 각각 비추상 서비스 및 추상 서비스의 개념 및 일례를 도시한다.
도 6 는 스크린 컨텍스트 및 각종 메소드와의 관계를 나타낸다.
도 7a 및 7b 는 로지컬 스크린의 z-order에 따른 디스플레이 스크린 상의 결과를 도시한다.
도 8a 및 8b 는 서비스 컨텍스트, 로지컬 스크린 및 디스플레이 스크린의 연관 관계를 도시한다.
도 9a 및 9b 는 로지컬 스크린이 맵핑되는 디스플레이 영역에 따른 디스플레이 스크린 상의 결과를 도시한다.
도 10 은 복수 개의 서비스, 복수 개의 로지컬 스크린 및 디스플레이 스크린의 연관 관계를 도시한다.
도 11a 은 본 발명의 일 실시예에 따른 'org.ocap.ui.MultiScreenConfigurableContext' 에서의 자바 상수 레지스트리를 도시한다.
도 11b 은 본 발명의 일 실시예에 따른 'org.ocap.ui.MultiScreenConfiguration' 에서의 자바 상수 레지스트리를 도시한다.
도 11c 은 본 발명의 일 실시예에 따른 'org.ocap.ui.MultiScreenContext' 상의 자바 상수 레지스트리를 도시한다.
도 11d 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenConfigurationEvent' 상의 자바 상수 레지스트리를 도시한다.
도 11e 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenContextEvent' 상의 자바 상수 레지스트리를 도시한다.
도 11f 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenEvent' 상의 자바 상수 레지스트리를 도시한다.
도 11g 은 본 발명의 일 실시예에 따른 'org.ocap.ui.event.MultiScreenResourceEvent' 상의 자바 상수 레지스트리를 도시한다.
도 12 는 본 발명의 일 실시예에 따른 자바 패키지 'org.ocap.ui'의 인터페이스 및 클래스를 도시한다.
도 13a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfigurableContext' 인터페이스의 정의를 도시한다.
도 13b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfigurableContext' 인터페이스의 필드를 도시한다.
도 13c 는 'CONFIGURABLE_SCREEN_PARAMETER_DEVICE_Z_ORDER' 필드의 사용례를 도시한다.
도 13d 내지 13f 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfigurableContext' 인터페이스의 메소드를 도시한다.
도 14a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스의 정의를 도시한다.
도 14b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스의 필드를 도시한다.
도 14c 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenConfiguration' 인터페이스의 메소드를 도시한다.
도 15a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenContext' 인터페이스의 정의를 도시한다.
도 15b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenContext' 인터페이스의 필드를 도시한다.
도 15c 및 15d는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenContext' 인터페이스의 메소드를 도시한다.
도 16a 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenManager' 클래스의 정의를 도시한다.
도 16b 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenManager' 클래스의 생성자를 도시한다.
도 16c 내지 16f 는 본 발명의 일 실시예에 따른 'org.ocap.ui' 패키지의 'MultiScreenManager' 클래스의 메소드를 도시한다.
도 17 은 본 발명의 일 실시예에 따른 자바 패키지 'org.ocap.ui.event'의 인터페이스 및 클래스를 도시한다.
도 18a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 정의를 도시한다.
도 18b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 필드를 도시한다.
도 18c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 생성자를 도시한다.
도 18d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationEvent' 클래스의 메소드를 도시한다.
도 19a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationListener' 인터페이스의 정의를 도시한다.
도 19b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenConfigurationListener' 인터페이스의 메소드를 도시한다.
도 20a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 정의를 도시한다.
도 20b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 필드를 도시한다.
도 20c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 생성자를 도시한다.
도 20d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextEvent' 클래스의 메소드를 도시한다.
도 21a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextListener' 인터페이스의 정의를 도시한다.
도 21b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenContextListener' 인터페이스의 메소드를 도시한다.
도 22a 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 클래스의 정의를 도시한다.
도 22b 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 클래스의 필드를 도시한다.
도 22c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenEvent' 클래스의 생성자를 도시한다.
도 22d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스의 메소드를 도시한다.
도 23a 는 본 발명의 일 실시예에 따른 org.ocap.ui.event 패키지의 'MultiScreenResourceEvent' 클래스의 정의를 도시한다.
도 23b 는 본 발명의 일 실시예에 따른 org.ocap.ui.event 패키지의 'MultiScreenResourceEvent' 클래스의 필드를 도시한다.
도 23c 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스의 생성자를 도시한다.
도 23d 는 본 발명의 일 실시예에 따른 'org.ocap.ui.event' 패키지의 'MultiScreenResourceEvent' 클래스의 메소드를 도시한다.
도 24a 내지 24c 는 본 발명의 일 실시예에 따른 멀티스크린 설정의 변경을 위한 전제 조건을 도시한다.
도 24d 는 본 발명의 일 실시예에 따른 멀티스크린 설정의 변경 과정을 도시한다.
도 25a 내지 25e 는 본 발명의 일 실시예에 따른 멀티스크린 설정의 변경을 위한 사후 조건을 도시한다.
도 26a 내지 26d 는 본 발명의 일 실시예에 따른 상태 불변성을 확인하기 위한 조건을 도시한다.
도 27 은 본 발명의 일 실시예에 따른 'getNonDefaultScreens()' 메소드의 정의를 도시한다.
도 28a 내지 28b 는 본 발명의 일 실시예에 따른 'getNonDefaultScreenDevices()' 메소드의 정의를 도시한다.
도 29 는 본 발명의 일 실시예에 따른 여러 메소드를 도시한다.
도 30a 은 OCAP 표준 규격의 AppID 자바 타입의 의사 코드를 도시한다.
도 30b 은 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'OcapAppID' 자바 타입의 의사 코드를 도시한다.
도 31 은 본 발명의 일 실시예에 따른 'OcapAppID' 자바 타입을 지원하기 위한 의사 코드를 도시한다.
도 32a 은 OCAP 표준 규격의 'HSceneBinding' 자바 타입의 의사 코드를 도시한다.
도 32b 은 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'HSceneBinding' 자바 타입의 의사 코드를 도시한다.
도 33a 는 OCAP 표준 규격의 'HSceneChangeRequestHandler' 자바 타입의 의사 코드를 도시한다.
도 33b 는 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'HSceneChangeRequestHandler' 자바 타입의 의사 코드를 도시한다.
도 34a 는 OCAP 표준 규격의 'HSceneManager' 자바 타입의 의사 코드를 도시한다.
도 34b 및 34c 는 본 발명의 일 실시예에 따른 OCAP MSM 구현을 위한 'HSceneManager' 자바 타입의 의사 코드를 도시한다.

Claims (7)

  1. 비디오, 오디오, 데이터 서비스 중에서 적어도 하나의 서비스를 수신하고, 상기 수신된 서비스(service context)를 표시하는 다중 스크린을 제공하는 장치에 있어서,
    상기 서비스 및 상기 스크린의 연관 관계, 상기 스크린 및 출력 포트의 연관 관계(associations), 및 상기 스크린의 배치 방식(screen configurations) 중 적어도 하나를 포함하는 상기 스크린의 스크린 속성(screen context) 중 설정 가능한 속성을 설정하는 스크린 속성 설정 모듈;
    상기 스크린의 배치 방식 및 스크린 배치 방식과 관련된 상기 스크린의 종류에 관한 정보를 확인하는 스크린 설정 모듈;
    상기 스크린 배치 방식에 따라 배치된 소정 스크린의 속성을 확인하는 스크린 속성 확인 모듈; 및
    상기 수신된 서비스를 상기 스크린 설정에 의해 상기 스크린에 표시하기 위한 설정 환경을 관리하는 스크린 관리 모듈을 포함하는 것을 특징으로 하는 다중 스크린을 제공하는 장치.
  2. 제 1 항에 있어서,
    상기 서비스는 적어도 하나의 서비스 컴포넌트로 표현되는 멀티미디어 컴포넌트이며, 상기 서비스 컴포넌트는 비디오 컴포넌트, 오디오 컴포넌트, 데이터 컴포넌트 중 하나인 것을 특징으로 하는 다중 스크린을 제공하는 장치.
  3. 제 1 항에 있어서,
    상기 다중 스크린을 지원하는 인터페이스를 구현하는 스크린은 적어도 하나인 것을 특징으로 하는 다중 스크린을 제공하는 장치.
  4. 제 1 항에 있어서,
    상기 다중 스크린은 상기 서비스와 연관된 논리 스크린 및 출력 포트와 연관된 출력 스크린을 포함하는 것을 특징으로 하는 다중 스크린을 제공하는 장치.
  5. 제 4 항에 있어서,
    상기 논리 스크린은 상기 출력 스크린과 연관되는 것을 특징으로 하는 다중 스크린을 제공하는 장치.
  6. 제 5 항에 있어서,
    상기 출력 스크린은 적어도 하나의 논리 스크린을 연관시키는 것을 특징으로 하는 다중 스크린을 제공하는 장치.
  7. 복수의 방송 서비스를 수신받는 단계;
    복수의 디스플레이 스크린의 각각이 물리적 디스플레이 장치의 출력 설정부를 나타내는 가상 스크린인 상기 복수의 디스플레이 스크린을 생성하는 단계;
    복수의 논리 스크린의 각각이 상기 복수의 디스플레이 스크린 중 하나의 디스플레이 스크린과 상기 복수의 디스플레이 스크린의 각각의 디스플레이 영역에 연관된 가상 스크린인 상기 복수의 논리 스크린을 생성하는 단계;
    상기 복수의 논리 스크린에 복수의 상기 방송 서비스를 연관시키는 단계;
    상기 복수의 논리 스크린을 상기 복수의 디스플레이 스크린에 연관시키는 단계;
    상기 복수의 디스플레이 스크린 중에서 활성화된 디스플레이 스크린을 포함하는 디스플레이 스크린 세트를 검색하는 단계; 및
    현재 디스플레이 스크린과 연관된 논리 스크린 중 활성화된 논리 스크린을 포함하는 스크린 세트를 검색하는 단계를 포함하고,
    상기 복수의 디스플레이 스크린의 각각은 선택적으로 비디오 출력 포트와 연관되지 않거나, 하나 이상의 비디오 출력 포트와 연관되고,
    상기 출력 포트의 각각은 외부 디바이스와의 연결을 위한 것을 특징으로 하는 멀티스크린 관리 방법.
KR1020070133705A 2006-12-18 2007-12-18 복수 개의 스크린 설정을 위한 멀티스크린 관리 방법 및장치 KR101476140B1 (ko)

Applications Claiming Priority (10)

Application Number Priority Date Filing Date Title
US87047106P 2006-12-18 2006-12-18
US60/870,471 2006-12-18
US91889407P 2007-03-20 2007-03-20
US60/918,894 2007-03-20
US94803807P 2007-07-05 2007-07-05
US60/948,038 2007-07-05
US97284607P 2007-09-17 2007-09-17
US60/972,846 2007-09-17
US97590607P 2007-09-28 2007-09-28
US60/975,906 2007-09-28

Publications (2)

Publication Number Publication Date
KR20080057187A KR20080057187A (ko) 2008-06-24
KR101476140B1 true KR101476140B1 (ko) 2014-12-24

Family

ID=39536460

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020070133705A KR101476140B1 (ko) 2006-12-18 2007-12-18 복수 개의 스크린 설정을 위한 멀티스크린 관리 방법 및장치

Country Status (8)

Country Link
US (1) US8054319B2 (ko)
EP (1) EP2095633A4 (ko)
KR (1) KR101476140B1 (ko)
CN (1) CN101632300B (ko)
BR (1) BRPI0720474A8 (ko)
CA (1) CA2672450A1 (ko)
MX (1) MX2009006596A (ko)
WO (1) WO2008075880A1 (ko)

Families Citing this family (39)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9182937B2 (en) 2010-10-01 2015-11-10 Z124 Desktop reveal by moving a logical display stack with gestures
US8698751B2 (en) 2010-10-01 2014-04-15 Z124 Gravity drop rules and keyboard display on a multiple screen device
KR101204795B1 (ko) * 2007-10-23 2012-11-26 삼성전자주식회사 이종의 그래픽 시스템 기반 어플리케이션들의 화면 공유방법 및 그 장치
KR101463567B1 (ko) * 2008-07-02 2014-11-20 엘지이노텍 주식회사 디지털 텔레비전의 단일 튜너를 이용한 피아이피기능구현장치
US20100064251A1 (en) * 2008-09-05 2010-03-11 International Business Machines Corporation Toggling window display state by screen in a multi-screened desktop environment
EP2270658A1 (en) * 2009-06-22 2011-01-05 Clayster Asia Ltd. Method and computer system for introducing client devices into a client-server network
KR101700811B1 (ko) 2010-09-02 2017-02-01 주식회사 케이티 이동형 사용자 단말 위치에 기반한 콘텐츠 연속 이용 제공 방법 및 서버
US9436217B2 (en) 2010-10-01 2016-09-06 Z124 Windows position control for phone applications
US20120220340A1 (en) * 2010-10-01 2012-08-30 Sanjiv Sirpal Windows position control for phone applications
US20120225694A1 (en) 2010-10-01 2012-09-06 Sanjiv Sirpal Windows position control for phone applications
US9189018B2 (en) 2010-10-01 2015-11-17 Z124 Windows position control for phone applications
US20120218202A1 (en) 2010-10-01 2012-08-30 Sanjiv Sirpal Windows position control for phone applications
US9430122B2 (en) 2010-10-01 2016-08-30 Z124 Secondary single screen mode activation through off-screen gesture area activation
US9733665B2 (en) * 2010-10-01 2017-08-15 Z124 Windows position control for phone applications
US9588545B2 (en) 2010-10-01 2017-03-07 Z124 Windows position control for phone applications
US20120225693A1 (en) 2010-10-01 2012-09-06 Sanjiv Sirpal Windows position control for phone applications
US9372618B2 (en) * 2010-10-01 2016-06-21 Z124 Gesture based application management
US11265510B2 (en) * 2010-10-22 2022-03-01 Litl Llc Video integration
US20120102403A1 (en) * 2010-10-22 2012-04-26 Robert Sanford Havoc Pennington Video integration
US10135900B2 (en) 2011-01-21 2018-11-20 Qualcomm Incorporated User input back channel for wireless displays
US9582239B2 (en) * 2011-01-21 2017-02-28 Qualcomm Incorporated User input back channel for wireless displays
US9787725B2 (en) 2011-01-21 2017-10-10 Qualcomm Incorporated User input back channel for wireless displays
US8878794B2 (en) 2011-09-27 2014-11-04 Z124 State of screen info: easel
JPWO2013061526A1 (ja) 2011-10-26 2015-04-02 パナソニック インテレクチュアル プロパティ コーポレーション オブアメリカＰａｎａｓｏｎｉｃ Ｉｎｔｅｌｌｅｃｔｕａｌ Ｐｒｏｐｅｒｔｙ Ｃｏｒｐｏｒａｔｉｏｎ ｏｆ Ａｍｅｒｉｃａ 放送受信装置、放送受信方法およびプログラム
US8799974B2 (en) * 2011-12-12 2014-08-05 Infosys Limited System and method for multi-standard browser for digital devices
US9395869B2 (en) 2012-02-02 2016-07-19 Apple Inc. Global z-order for windows
US9407961B2 (en) * 2012-09-14 2016-08-02 Intel Corporation Media stream selective decode based on window visibility state
KR102069547B1 (ko) 2013-04-19 2020-01-28 삼성전자주식회사 방송 통신 시스템에서 부가 정보를 송수신하는 방법 및 장치
KR20150004156A (ko) * 2013-07-02 2015-01-12 삼성전자주식회사 디스플레이 장치 및 그 방법
KR102099594B1 (ko) * 2013-10-23 2020-04-10 엘지전자 주식회사 Tv 및 그 동작 방법
US10275139B2 (en) * 2014-09-18 2019-04-30 Sony Interactive Entertainment LLC System and method for integrated user interface for electronic devices
KR101594105B1 (ko) 2015-03-06 2016-02-16 주식회사 와이젯 사용자 장치 간에 여러 화면을 분배하고 입력 인터페이스를 공유하는 멀티 스크린 구현 방법 및 장치
US10585869B2 (en) * 2015-05-22 2020-03-10 Open Text Holdings, Inc. System and method for generating, maintaining, and querying a database for computer investigations
KR101916728B1 (ko) * 2016-03-07 2018-11-08 엘지전자 주식회사 차량에 구비된 차량 제어 장치 및 그의 제어방법
WO2017155219A1 (en) 2016-03-07 2017-09-14 Lg Electronics Inc. Vehicle control device mounted in vehicle and control method thereof
CN106227594A (zh) * 2016-07-11 2016-12-14 中国人民解放军国防科学技术大学 一种基于分屏的多核cpu帧缓存显示优化方法
US10795630B2 (en) 2018-10-10 2020-10-06 International Business Machines Corporation Configuring computing device to utilize a multiple display arrangement by tracking eye movement
US11301456B2 (en) * 2020-05-07 2022-04-12 Sap Se Processing consistency validations of conditional foreign-key relations
CN114071199B (zh) * 2020-08-07 2024-03-12 惠州视维新技术有限公司 一种屏幕控制方法、终端设备以及存储介质

Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5347624A (en) * 1987-03-05 1994-09-13 Hitachi, Ltd. Method and apparatus for display control

Family Cites Families (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5289574A (en) * 1990-09-17 1994-02-22 Hewlett-Packard Company Multiple virtual screens on an "X windows" terminal
JPH06268908A (ja) * 1993-03-10 1994-09-22 Toshiba Corp マルチ画面用枠信号発生回路
US6088005A (en) * 1996-01-11 2000-07-11 Hewlett-Packard Company Design and method for a large, virtual workspace
JP4541476B2 (ja) 1999-02-19 2010-09-08 キヤノン株式会社 マルチ画像表示システムおよびマルチ画像表示方法
JP2002335444A (ja) * 2001-05-08 2002-11-22 Canon Inc マルチ画面表示装置、マルチ画面表示方法、記録媒体、及びプログラム
AU2002241369B2 (en) * 2002-03-20 2009-05-28 Eugene Science Inc. Mixing powder of plant sterol and emulsifier, and method for preparing the same
JP2003309780A (ja) * 2002-04-18 2003-10-31 Matsushita Electric Ind Co Ltd 画像表示装置
JP2006049935A (ja) * 2003-04-17 2006-02-16 Fujitsu Ltd 映像制御機能を備える制御装置及びプログラム
KR20050056901A (ko) * 2003-12-10 2005-06-16 마쯔시다덴기산교 가부시키가이샤 휴대 정보 단말 장치
KR100710301B1 (ko) * 2005-01-14 2007-04-23 엘지전자 주식회사 멀티-스크린 시스템 및 그 구현방법

Patent Citations (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5347624A (en) * 1987-03-05 1994-09-13 Hitachi, Ltd. Method and apparatus for display control

Also Published As

Publication number Publication date
BRPI0720474A2 (pt) 2014-01-14
US20090322714A1 (en) 2009-12-31
EP2095633A1 (en) 2009-09-02
CN101632300B (zh) 2012-07-04
MX2009006596A (es) 2009-07-02
BRPI0720474A8 (pt) 2017-09-12
KR20080057187A (ko) 2008-06-24
CN101632300A (zh) 2010-01-20
EP2095633A4 (en) 2014-04-16
WO2008075880A1 (en) 2008-06-26
CA2672450A1 (en) 2008-06-26
US8054319B2 (en) 2011-11-08

Similar Documents

Publication Publication Date Title
KR101476140B1 (ko) 복수 개의 스크린 설정을 위한 멀티스크린 관리 방법 및장치
KR20080092328A (ko) 다중 스크린을 제공하는 장치 및 상기 다중 스크린의 동적 구성 방법
IL200900A (en) Programmable Multimedia Systems and Programmable Programmable Remote Control Programmable Methods in Digital Display
CN113038160B (zh) 一种显示设备及音视频数据的播放方法
US9681178B2 (en) Distributed presentation software for multiple instantiations in home network
CN112584210B (zh) 显示设备、视频录制方法及录制文件展示方法
CN111324437A (zh) 操作系统的内核函数调用方法及计算机设备
CA2648597A1 (en) Apparatus and method for managing resource in multiple screens environment
TW200849990A (en) Method and apparatus for multiscreen management for multiple screen configuration
KR100917885B1 (ko) 복수 개의 스크린을 제공하는 방법 및 장치, 그리고 상기 복수 개의 스크린 제공 방법이 기록된 컴퓨터로 판독 가능한 기록 매체
KR100725421B1 (ko) 다중 스크린을 제공하는 장치 및 상기 다중 스크린의 동적구성 방법
Monnier MHP/OCAP iTV Applications in a Nutshell
WO2007114643A1 (en) Apparatus and method for managing resource in multiple screens environment
EP1911277A1 (en) Apparatus for providing multiple screens and method of dynamically configuring multiple screens
KR100888595B1 (ko) 다중 스크린을 제공하는 장치 및 상기 다중 스크린의 동적구성 방법
KR100746041B1 (ko) 다중 스크린을 제공하는 장치 및 상기 다중 스크린의 동적구성 방법
KR20070100110A (ko) 다중 스크린을 제공하는 장치 및 상기 다중 스크린의 동적구성 방법
KR20070017012A (ko) 다중 스크린을 제공하는 장치 및 상기 다중 스크린의 동적구성 방법
KR20070017003A (ko) 다중 스크린을 제공하는 장치 및 상기 다중 스크린의 동적구성 방법
JP2001027955A (ja) 複数の端末と、すべての端末に配布されるソフトウェアシステムとを有するネットワーク

Legal Events

Date Code Title Description
G170 Re-publication after modification of scope of protection [patent]
A201 Request for examination
E902 Notification of reason for refusal
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20171129

Year of fee payment: 4

LAPS Lapse due to unpaid annual fee