001: /*
002: *
003: *
004: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: */
026: package com.sun.midp.jsr82emul;
027:
028: import com.sun.midp.log.Logging;
029: import com.sun.kvem.jsr082.bluetooth.SDPServer;
030:
031: /**
032: * Emulation unit is an entity that can process requests from
033: * porting layer.
034: */
035: interface EmulUnit {
036: /**
037: * Processes a request from porting layer to emulation.
038: * @param request serialized requests sequence with current
039: * offset that points to request to be processed.
040: */
041: public void process(BytePack request);
042: }
043:
044: /**
045: * A emulation unit which is actually a controller that passes request
046: * to one of predefined units saved in an array.
047: */
048: abstract class EmulUnitCaller implements EmulUnit {
049: /** Units to pass requests to. */
050: protected EmulUnit[] callee;
051:
052: /**
053: * Processes requests. The only supported type of requests is:
054: * pass request to the unit with given index.
055: * @param request serialized requests under processing.
056: */
057: public void process(BytePack request) {
058: int id = request.extract();
059: callee[id].process(request);
060: }
061: }
062:
063: /**
064: * Main controller that passes request to proper units for processing.
065: */
066: class MainCaller extends EmulUnitCaller {
067: /** The only instance. */
068: private static MainCaller instance = new MainCaller();
069:
070: /** Constructs the instance. */
071: private MainCaller() {
072: new SDPServer().start();
073:
074: callee = new EmulUnit[] { DeviceEmul.getLocalDeviceEmul(),
075: new NotifierCreator(), new ConnectionCreator(),
076: ConnRegistry.getInstance() };
077: }
078:
079: /**
080: * Retrieves the only instance.
081: * @return (reference to) the only instance.
082: */
083: static MainCaller getInstance() {
084: return instance;
085: }
086: }
087:
088: /** Emulation unit that supports requests for a notifier creation. */
089: class NotifierCreator implements EmulUnit {
090: /**
091: * Processes requests.
092: * @param request serialized requests under processing.
093: */
094: public void process(BytePack request) {
095: // It registers itself as a requests processor
096: new NotifierEmul(request.extract());
097: }
098: }
099:
100: /** Emulation unit that supports requests for a connection creation. */
101: class ConnectionCreator implements EmulUnit {
102: /**
103: * Processes requests.
104: * @param request serialized requests under processing.
105: */
106: public void process(BytePack request) {
107: // It registers itself as a requests processor
108: new ConnectionEmul(request.extract());
109: }
110: }
111:
112: /**
113: * Emulation unit that keeps reference for all available connections and
114: * notifiers and passes requests to them. It is singleton that keeps
115: * one and the only instance of the registry.
116: */
117: class ConnRegistry extends EmulUnitCaller {
118: /** Keeps the registry instance. */
119: private static ConnRegistry instance = new ConnRegistry();
120:
121: /** Creates instance. */
122: private ConnRegistry() {
123: callee = new EmulUnit[Const.MAX_CONN];
124: }
125:
126: /**
127: * Retrieves the only instance.
128: * @return (reference to) the only instance.
129: */
130: static ConnRegistry getInstance() {
131: return instance;
132: }
133:
134: /**
135: * Registers a newly created connection or notifier in the registry.
136: * @param handle handle that identifies the unit to be registered,
137: * must be in a range from 0 to <code>Const.MAX_CONN</code>.
138: * @param unit either connection or notifier to be registered.
139: */
140: void register(int handle, EmulUnit unit) {
141: callee[handle] = unit;
142: }
143:
144: /**
145: * Removes connection or notifier with given handle form the registry.
146: * @param handle handle that identifies the unit to be removed
147: */
148: void unregister(int handle) {
149: callee[handle] = null;
150: }
151: }
152:
153: // IMPL_NOTE move to Constants.xml
154: /** A set of emulation constants. */
155: class Const {
156: /** Size of requests queue. */
157: static final int DEFAULT_QUEUE_SIZE = 512;
158:
159: /**
160: * Maximum amount of connections and notifiers objects supported
161: * by emulation.
162: */
163: static final int MAX_CONN = 16;
164: /** Size of byte representation of Bluetooth address. */
165: static final int BTADDR_SIZE = 6;
166: /** Size of byte representation of IP address. */
167: static final int IP_SIZE = 4;
168: /**
169: * Value that indicates send or receive operation failure when passed
170: * as amount of bytes sent or received.
171: */
172: static final int CONN_FAILURE = -2;
173: /**
174: * Value that indicates reaching end of input stream.
175: */
176: static final int CONN_ENDOF_INP = -1;
177: }
|