| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package flash.tools.debugger.threadsafe; |
| |
| import java.io.IOException; |
| |
| import flash.tools.debugger.AIRLaunchInfo; |
| import flash.tools.debugger.IDebuggerCallbacks; |
| import flash.tools.debugger.ILaunchNotification; |
| import flash.tools.debugger.ILauncher; |
| import flash.tools.debugger.IProgress; |
| import flash.tools.debugger.Player; |
| import flash.tools.debugger.Session; |
| import flash.tools.debugger.SessionManager; |
| import flash.tools.debugger.SessionManager2; |
| |
| /** |
| * Thread-safe wrapper for flash.tools.debugger.SessionManager |
| * @author Mike Morearty |
| */ |
| public class ThreadSafeSessionManager extends ThreadSafeDebuggerObject implements SessionManager2 { |
| |
| private SessionManager fSessionManager; |
| |
| private ThreadSafeSessionManager(SessionManager sessionManager) { |
| super(new Object()); |
| fSessionManager = sessionManager; |
| } |
| |
| /** |
| * Wraps a SessionManager inside a ThreadSafeSessionManager. If the passed-in SessionManager |
| * is null, then this function returns null. |
| */ |
| public static ThreadSafeSessionManager wrap(SessionManager sessionManager) { |
| if (sessionManager != null) |
| return new ThreadSafeSessionManager(sessionManager); |
| else |
| return null; |
| } |
| |
| public static Object getSyncObject(SessionManager sm) { |
| return ((ThreadSafeSessionManager)sm).getSyncObject(); |
| } |
| |
| public Session accept(IProgress waitReporter) throws IOException { |
| // WARNING: This function is not thread-safe. |
| // |
| // accept() can take a very long time -- e.g. if there is something wrong, |
| // then it might hang for two minutes while waiting for the Flash player. |
| // So, it is not acceptable to put this in a "synchronized" block. |
| return ThreadSafeSession.wrap(getSyncObject(), fSessionManager.accept(waitReporter)); |
| } |
| |
| public int getPreference(String pref) throws NullPointerException { |
| synchronized (getSyncObject()) { |
| return fSessionManager.getPreference(pref); |
| } |
| } |
| |
| public boolean isListening() { |
| synchronized (getSyncObject()) { |
| return fSessionManager.isListening(); |
| } |
| } |
| |
| public Session launch(String uri, AIRLaunchInfo airLaunchInfo, boolean forDebugging, IProgress waitReporter, ILaunchNotification launchNotification) throws IOException { |
| // WARNING: This function is not thread-safe. |
| // |
| // launch() can take a very long time -- e.g. if there is something wrong, |
| // then it might hang for two minutes while waiting for the Flash player. |
| // So, it is not acceptable to put this in a "synchronized" block. |
| return ThreadSafeSession.wrap(getSyncObject(), fSessionManager.launch(uri, airLaunchInfo, forDebugging, waitReporter,launchNotification)); |
| } |
| |
| public Player playerForUri(String uri, AIRLaunchInfo airLaunchInfo) { |
| synchronized (getSyncObject()) { |
| return ThreadSafePlayer.wrap(getSyncObject(), fSessionManager.playerForUri(uri, airLaunchInfo)); |
| } |
| } |
| |
| public boolean supportsLaunch() |
| { |
| synchronized (getSyncObject()) { |
| return fSessionManager.supportsLaunch(); |
| } |
| } |
| |
| public void setPreference(String pref, int value) { |
| synchronized (getSyncObject()) { |
| fSessionManager.setPreference(pref, value); |
| } |
| } |
| |
| public void setPreference(String pref, String value) { |
| synchronized (getSyncObject()) { |
| fSessionManager.setPreference(pref, value); |
| } |
| } |
| |
| public void startListening() throws IOException { |
| synchronized (getSyncObject()) { |
| fSessionManager.startListening(); |
| } |
| } |
| |
| public void stopListening() throws IOException { |
| synchronized (getSyncObject()) { |
| fSessionManager.stopListening(); |
| } |
| } |
| |
| public void setDebuggerCallbacks(IDebuggerCallbacks debuggerCallbacks) { |
| synchronized (getSyncObject()) { |
| fSessionManager.setDebuggerCallbacks(debuggerCallbacks); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see flash.tools.debugger.SessionManager#connect(int, flash.tools.debugger.IProgress) |
| */ |
| public Session connect(int port, IProgress waitReporter) throws IOException { |
| // WARNING: This function is not thread-safe. |
| // |
| // connect() can take a very long time -- e.g. if there is something wrong, |
| // then it might hang for two minutes while waiting for the Flash player. |
| // So, it is not acceptable to put this in a "synchronized" block. |
| return ThreadSafeSession.wrap(getSyncObject(), fSessionManager.connect(port, waitReporter)); |
| } |
| |
| public void stopConnecting() throws IOException { |
| synchronized (getSyncObject()) { |
| fSessionManager.stopConnecting(); |
| } |
| } |
| |
| public boolean isConnecting() { |
| synchronized (getSyncObject()) { |
| return fSessionManager.isConnecting(); |
| } |
| } |
| |
| @Override |
| public Process launchForRun(String uri, AIRLaunchInfo airLaunchInfo, |
| IProgress waitReporter, ILaunchNotification launchNotification) |
| throws IOException { |
| /* |
| * launch used to return null when the session was null. |
| * The session will be null in this case because this is invoked for run launches. |
| * We just return the process to be consistent with PlayerSessionManager. |
| */ |
| assert fSessionManager instanceof SessionManager2; |
| |
| Process process = ((SessionManager2) fSessionManager).launchForRun(uri, airLaunchInfo, waitReporter, launchNotification); |
| |
| return process; |
| } |
| |
| @Override |
| public Process launchForRun(String uri, AIRLaunchInfo airLaunchInfo, |
| IProgress waitReporter, ILaunchNotification launchNotification, |
| ILauncher launcher) throws IOException { |
| /* |
| * launch used to return null when the session was null. |
| * The session will be null in this case because this is invoked for run launches. |
| * We just return the process to be consistent with PlayerSessionManager. |
| */ |
| assert fSessionManager instanceof SessionManager2; |
| |
| Process process = ((SessionManager2) fSessionManager).launchForRun(uri, airLaunchInfo, waitReporter, launchNotification,launcher); |
| |
| return process; |
| } |
| |
| @Override |
| public Session launch(String uri, AIRLaunchInfo airLaunchInfo, |
| boolean forDebugging, IProgress waitReporter, |
| ILaunchNotification launchNotification, ILauncher launcher) |
| throws IOException { |
| // WARNING: This function is not thread-safe. |
| // |
| // launch() can take a very long time -- e.g. if there is something wrong, |
| // then it might hang for two minutes while waiting for the Flash player. |
| // So, it is not acceptable to put this in a "synchronized" block. |
| assert fSessionManager instanceof SessionManager2; |
| |
| return ThreadSafeSession.wrap(getSyncObject(), ((SessionManager2) fSessionManager).launch(uri, airLaunchInfo, forDebugging, waitReporter,launchNotification,launcher)); |
| } |
| } |