jsampler/android/JSamplerActivity.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2011 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of JSampler.
 *
 *   JSampler is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   JSampler is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with JSampler; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.jsampler.android;

import java.util.TreeMap;

import net.sf.juife.PDUtils;
import net.sf.juife.impl.AndroidPDUtilsImpl;

import org.jsampler.CC;
import org.jsampler.HF;
import org.jsampler.JSampler;
import org.jsampler.android.view.std.ChooseBackendActivity;
import org.jsampler.android.view.std.JSamplerHomeChooser;

import android.app.Activity;
import android.app.Dialog;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.MotionEvent;


public class JSamplerActivity extends Activity {
        public static final int DLG_CHOOSE_HOME_DIR = 0;
        
        public static final int CHOOSE_BACKEND_REQUEST = 1000;
        
        private boolean started = false;
        
        private final TreeMap<Integer, Requestor> requestorMap = new TreeMap<Integer, Requestor> ();
        
        private GestureDetector gestureDetector;
        
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                
                gestureDetector = new GestureDetector(this, gestureListener);
                
                //showDialog(DLG_ADD_BACKEND);
                
                AndroidPDUtilsImpl.activity = this;
                AHF.setActivity(this);
                
                if(!HF.canReadWriteFiles(System.getProperty("user.home"))) {
                        // FIXME: workaround to make java.util.prefs to work properly
                        System.setProperty("user.home", getFilesDir().getAbsolutePath());
                }
                
                if(!started) {
                        JSampler.main(null);
                        started = true;
                }
                
                AHF.getMainFrame().onCreate();
                setContentView(AHF.getMainFrame().getView());
                
        }
        
        private SimpleOnGestureListener gestureListener = new SimpleOnGestureListener() {
                public boolean
                onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
                        return AHF.getMainFrame().onFling(e1, e2, velocityX, velocityY);
                }
                
                public boolean
                onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
                        return AHF.getMainFrame().onFling(e1, e2, distanceX, distanceY);
                }
        };
        
        /*public boolean
        onTouchEvent(MotionEvent event) {
                return gestureDetector.onTouchEvent(event);
        }*/
        
        public boolean
        dispatchTouchEvent(MotionEvent event) {
                boolean b = gestureDetector.onTouchEvent(event);
                if (!b) return super.dispatchTouchEvent(event);
                return b;
        }
        
        @Override
        protected void
        onActivityResult(int requestCode, int resultCode, Intent data) {
                super.onActivityResult(requestCode, resultCode, data);
                
                if(resultCode != Activity.RESULT_OK) return;
                
                switch(requestCode) {
                case CHOOSE_BACKEND_REQUEST:
                        Requestor r = requestorMap.get(CHOOSE_BACKEND_REQUEST);
                        if(r == null) return;
                        Log.w("JSamplerActivity", "onActivityResult: CHOOSE_BACKEND_REQUEST");
                        r.setResult(data);
                        requestorMap.remove(CHOOSE_BACKEND_REQUEST);
                break;
                }
        }

        
        @Override
        protected void onDestroy() {
                super.onDestroy();
                AHF.getMainFrame().uninstall();
                
                // postpone
                PDUtils.runOnUiThread(new Runnable() {
                        public void
                        run() { CC.cleanExit(); }
                });
        }
        
        @Override
        protected Dialog onCreateDialog(int id) {
                Dialog dialog;
                
                switch(id) {
                case DLG_CHOOSE_HOME_DIR:
                        dialog = new JSamplerHomeChooser(this);
                        break;
                default:
                        dialog = null;
                }
                
                return dialog;
        }
        
        @Override
        public boolean
        onCreateOptionsMenu(Menu menu) {
                MenuInflater inflater = getMenuInflater();
                inflater.inflate(R.menu.jsampler_options_menu, menu);
                return true;
        }
        
        @Override
        public boolean
        onOptionsItemSelected(MenuItem item) {
                switch (item.getItemId()) {
                case R.id.jsampler_options_menu_choose_backend:
                        CC.changeBackend();
                        return true;
                default:
                        return super.onOptionsItemSelected(item);
                }
        }
        
        public static <R> R
        getLocalResult(Intent i) {
                try {
                        if(i == null) return null;
                        
                        return (R)i.getSerializableExtra("org.jsampler.SomeSerializableObject");
                } catch(ClassCastException e) {
                        e.printStackTrace();
                }
                
                return null;
        }
        
        public static abstract class Requestor<R> {
                private final int requestId;
                
                /**
                 * Creates a requestor which is used to start a local activity.
                 * @param requestId Specifies the activity to be started.
                 * @see #startLocalActivity
                 */
                public Requestor(int requestId) {
                        this.requestId = requestId;
                }
                
                private void
                setResult(Intent data) {
                        onResult(JSamplerActivity.<R>getLocalResult(data));
                }
                
                /**
                 * Invoked when the activity is finished with result. 
                 * @param res The result obtained from the activity.
                 */
                public abstract void onResult(R res);
        }
        
        /**
         * Creates a local intent (for app internal use) if currently
         * there is no registered requestor for the intended activity. 
         * @param requestId Used to determine the activity which should be started.
         * @return The newly created intent or <code>null</code> if the request ID is uknown
         * or if there is already registered requestor for the intended activity.
         */
        private Intent
        createLocalIntent(int requestId) {
                if(requestorMap.containsKey(requestId)) {
                        Log.w("request ID: " + requestId, "There is a registered requestor for this activity");
                        return null;
                }
                switch(requestId) {
                case CHOOSE_BACKEND_REQUEST:
                        return new Intent(this, ChooseBackendActivity.class);
                default:
                        Log.w("createLocalIntent", "Unknown request ID: " + requestId);
                        return null;
                }
        }
        
        /** Starts an app local activity. */
        public void
        startLocalActivity(Requestor requestor) {
                Intent intent = createLocalIntent(requestor.requestId);
                if(intent == null) return;
                requestorMap.put(requestor.requestId, requestor);
                startActivityForResult(intent, CHOOSE_BACKEND_REQUEST);
        }
}
1	/*
2	* JSampler - a java front-end for LinuxSampler
3	*
4	* Copyright (C) 2011 Grigor Iliev <grigor@grigoriliev.com>
5	*
6	* This file is part of JSampler.
7	*
8	* JSampler is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2
10	* as published by the Free Software Foundation.
11	*
12	* JSampler is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with JSampler; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20	* MA 02111-1307 USA
21	*/
22
23	package org.jsampler.android;
24
25	import java.util.TreeMap;
26
27	import net.sf.juife.PDUtils;
28	import net.sf.juife.impl.AndroidPDUtilsImpl;
29
30	import org.jsampler.CC;
31	import org.jsampler.HF;
32	import org.jsampler.JSampler;
33	import org.jsampler.android.view.std.ChooseBackendActivity;
34	import org.jsampler.android.view.std.JSamplerHomeChooser;
35
36	import android.app.Activity;
37	import android.app.Dialog;
38	import android.content.Intent;
39	import android.os.Bundle;
40	import android.util.Log;
41	import android.view.GestureDetector;
42	import android.view.GestureDetector.SimpleOnGestureListener;
43	import android.view.Menu;
44	import android.view.MenuInflater;
45	import android.view.MenuItem;
46	import android.view.MotionEvent;
47
48
49	public class JSamplerActivity extends Activity {
50	public static final int DLG_CHOOSE_HOME_DIR = 0;
51
52	public static final int CHOOSE_BACKEND_REQUEST = 1000;
53
54	private boolean started = false;
55
56	private final TreeMap<Integer, Requestor> requestorMap = new TreeMap<Integer, Requestor> ();
57
58	private GestureDetector gestureDetector;
59
60	/** Called when the activity is first created. */
61	@Override
62	public void onCreate(Bundle savedInstanceState) {
63	super.onCreate(savedInstanceState);
64
65	gestureDetector = new GestureDetector(this, gestureListener);
66
67	//showDialog(DLG_ADD_BACKEND);
68
69	AndroidPDUtilsImpl.activity = this;
70	AHF.setActivity(this);
71
72	if(!HF.canReadWriteFiles(System.getProperty("user.home"))) {
73	// FIXME: workaround to make java.util.prefs to work properly
74	System.setProperty("user.home", getFilesDir().getAbsolutePath());
75	}
76
77	if(!started) {
78	JSampler.main(null);
79	started = true;
80	}
81
82	AHF.getMainFrame().onCreate();
83	setContentView(AHF.getMainFrame().getView());
84
85	}
86
87	private SimpleOnGestureListener gestureListener = new SimpleOnGestureListener() {
88	public boolean
89	onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
90	return AHF.getMainFrame().onFling(e1, e2, velocityX, velocityY);
91	}
92
93	public boolean
94	onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
95	return AHF.getMainFrame().onFling(e1, e2, distanceX, distanceY);
96	}
97	};
98
99	/*public boolean
100	onTouchEvent(MotionEvent event) {
101	return gestureDetector.onTouchEvent(event);
102	}*/
103
104	public boolean
105	dispatchTouchEvent(MotionEvent event) {
106	boolean b = gestureDetector.onTouchEvent(event);
107	if (!b) return super.dispatchTouchEvent(event);
108	return b;
109	}
110
111	@Override
112	protected void
113	onActivityResult(int requestCode, int resultCode, Intent data) {
114	super.onActivityResult(requestCode, resultCode, data);
115
116	if(resultCode != Activity.RESULT_OK) return;
117
118	switch(requestCode) {
119	case CHOOSE_BACKEND_REQUEST:
120	Requestor r = requestorMap.get(CHOOSE_BACKEND_REQUEST);
121	if(r == null) return;
122	Log.w("JSamplerActivity", "onActivityResult: CHOOSE_BACKEND_REQUEST");
123	r.setResult(data);
124	requestorMap.remove(CHOOSE_BACKEND_REQUEST);
125	break;
126	}
127	}
128
129
130	@Override
131	protected void onDestroy() {
132	super.onDestroy();
133	AHF.getMainFrame().uninstall();
134
135	// postpone
136	PDUtils.runOnUiThread(new Runnable() {
137	public void
138	run() { CC.cleanExit(); }
139	});
140	}
141
142	@Override
143	protected Dialog onCreateDialog(int id) {
144	Dialog dialog;
145
146	switch(id) {
147	case DLG_CHOOSE_HOME_DIR:
148	dialog = new JSamplerHomeChooser(this);
149	break;
150	default:
151	dialog = null;
152	}
153
154	return dialog;
155	}
156
157	@Override
158	public boolean
159	onCreateOptionsMenu(Menu menu) {
160	MenuInflater inflater = getMenuInflater();
161	inflater.inflate(R.menu.jsampler_options_menu, menu);
162	return true;
163	}
164
165	@Override
166	public boolean
167	onOptionsItemSelected(MenuItem item) {
168	switch (item.getItemId()) {
169	case R.id.jsampler_options_menu_choose_backend:
170	CC.changeBackend();
171	return true;
172	default:
173	return super.onOptionsItemSelected(item);
174	}
175	}
176
177	public static <R> R
178	getLocalResult(Intent i) {
179	try {
180	if(i == null) return null;
181
182	return (R)i.getSerializableExtra("org.jsampler.SomeSerializableObject");
183	} catch(ClassCastException e) {
184	e.printStackTrace();
185	}
186
187	return null;
188	}
189
190	public static abstract class Requestor<R> {
191	private final int requestId;
192
193	/**
194	* Creates a requestor which is used to start a local activity.
195	* @param requestId Specifies the activity to be started.
196	* @see #startLocalActivity
197	*/
198	public Requestor(int requestId) {
199	this.requestId = requestId;
200	}
201
202	private void
203	setResult(Intent data) {
204	onResult(JSamplerActivity.<R>getLocalResult(data));
205	}
206
207	/**
208	* Invoked when the activity is finished with result.
209	* @param res The result obtained from the activity.
210	*/
211	public abstract void onResult(R res);
212	}
213
214	/**
215	* Creates a local intent (for app internal use) if currently
216	* there is no registered requestor for the intended activity.
217	* @param requestId Used to determine the activity which should be started.
218	* @return The newly created intent or <code>null</code> if the request ID is uknown
219	* or if there is already registered requestor for the intended activity.
220	*/
221	private Intent
222	createLocalIntent(int requestId) {
223	if(requestorMap.containsKey(requestId)) {
224	Log.w("request ID: " + requestId, "There is a registered requestor for this activity");
225	return null;
226	}
227	switch(requestId) {
228	case CHOOSE_BACKEND_REQUEST:
229	return new Intent(this, ChooseBackendActivity.class);
230	default:
231	Log.w("createLocalIntent", "Unknown request ID: " + requestId);
232	return null;
233	}
234	}
235
236	/** Starts an app local activity. */
237	public void
238	startLocalActivity(Requestor requestor) {
239	Intent intent = createLocalIntent(requestor.requestId);
240	if(intent == null) return;
241	requestorMap.put(requestor.requestId, requestor);
242	startActivityForResult(intent, CHOOSE_BACKEND_REQUEST);
243	}
244	}