Java tutorial
/** * * Funf: Open Sensing Framework * Copyright (C) 2010-2011 Nadav Aharony, Wei Pan, Alex Pentland. * Acknowledgments: Alan Gardner * Contact: nadav@media.mit.edu * * This file is part of Funf. * * Funf is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation, either version 3 of * the License, or (at your option) any later version. * * Funf 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with Funf. If not, see <http://www.gnu.org/licenses/>. * */ package funf.config; import static funf.util.LogUtil.TAG; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; import java.lang.reflect.Type; import java.util.Collections; import org.apache.http.ParseException; import android.content.Context; import android.util.Log; import com.google.gson.FieldNamingPolicy; import com.google.gson.Gson; import com.google.gson.InstanceCreator; import com.google.gson.JsonElement; import com.google.gson.JsonObject; import com.google.gson.TypeAdapter; import com.google.gson.TypeAdapterFactory; import com.google.gson.internal.ConstructorConstructor; import com.google.gson.internal.Excluder; import com.google.gson.internal.Streams; import bind.JsonTreeReader; import bind.JsonTreeWriter; import funf.util.LogUtil; import com.google.gson.internal.bind.ReflectiveTypeAdapterFactory; import com.google.gson.reflect.TypeToken; import com.google.gson.stream.JsonReader; import com.google.gson.stream.JsonWriter; public class DefaultRuntimeTypeAdapterFactory<E> implements RuntimeTypeAdapterFactory { private final Context context; private final Class<E> baseClass; private final Class<? extends E> defaultClass; private TypeAdapterFactory delegateFactory; /** * Use the base class as the default class. * @param context * @param baseClass */ public DefaultRuntimeTypeAdapterFactory(Context context, Class<E> baseClass) { this(context, baseClass, null); } public DefaultRuntimeTypeAdapterFactory(Context context, Class<E> baseClass, Class<? extends E> defaultClass) { this(context, baseClass, defaultClass, null); } /** * @param context * @param baseClass * @param defaultClass Setting this to null will cause a ParseException if the runtime type information is incorrect or unavailable. */ public DefaultRuntimeTypeAdapterFactory(Context context, Class<E> baseClass, Class<? extends E> defaultClass, TypeAdapterFactory delegateFactory) { assert context != null && baseClass != null; if (defaultClass != null && !isInstantiable(defaultClass)) { throw new RuntimeException("Default class does not have a default contructor."); } this.context = context; this.baseClass = baseClass; this.defaultClass = defaultClass; if (delegateFactory == null) { this.delegateFactory = new ReflectiveTypeAdapterFactory( new ConstructorConstructor(Collections.<Type, InstanceCreator<?>>emptyMap()), FieldNamingPolicy.IDENTITY, Excluder.DEFAULT); } else { this.delegateFactory = delegateFactory; } } @SuppressWarnings("unchecked") @Override public <T> Class<? extends T> getRuntimeType(JsonElement el, TypeToken<T> type) { if (baseClass.isAssignableFrom(type.getRawType())) { // 1 use type if instatiable // 2 use default if type cannot be instantiated and type is assignable from type // 3 fail final boolean canUseDefaultClass = defaultClass != null && type.getRawType().isAssignableFrom(defaultClass); final boolean typeIsInstantiable = DefaultRuntimeTypeAdapterFactory .isTypeInstatiable(type.getRawType()); final Class<? extends T> defautRuntimeClass = (Class<? extends T>) (typeIsInstantiable ? type.getRawType() : (canUseDefaultClass ? defaultClass : null)); return DefaultRuntimeTypeAdapterFactory.getRuntimeType(el, (Class<T>) type.getRawType(), defautRuntimeClass); } return null; } @Override public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> type) { if (baseClass.isAssignableFrom(type.getRawType())) { return new TypeAdapter<T>() { @Override public void write(JsonWriter out, T value) throws IOException { if (value == null) { out.nullValue(); return; } // TODO: cache these only once per runtime type final TypeAdapter delegate = delegateFactory.create(gson, TypeToken.get(value.getClass())); JsonTreeWriter treeWriter = new JsonTreeWriter(); delegate.write(treeWriter, value); JsonElement el = treeWriter.get(); if (el.isJsonObject()) { JsonObject elObject = el.getAsJsonObject(); elObject.addProperty(RuntimeTypeAdapterFactory.TYPE, value.getClass().getName()); Streams.write(elObject, out); } else { Streams.write(el, out); } } @Override public T read(JsonReader in) throws IOException { // TODO: need to handle null JsonElement el = Streams.parse(in); Class<? extends T> runtimeType = getRuntimeType(el, type); if (runtimeType == null) { throw new ParseException("RuntimeTypeAdapter: Unable to parse runtime type."); } // TODO: cache these only once per runtime type final TypeAdapter<? extends T> delegate = delegateFactory.create(gson, TypeToken.get(runtimeType)); if (el.isJsonPrimitive() && el.getAsJsonPrimitive().isString()) { JsonObject typeObject = new JsonObject(); typeObject.addProperty(TYPE, el.getAsString()); el = typeObject; } return delegate.read(new JsonTreeReader(el)); } }; } return null; } @SuppressWarnings("unchecked") public static <T> Class<? extends T> getRuntimeType(JsonElement el, Class<T> baseClass, Class<? extends T> defaultClass) { Class<? extends T> type = defaultClass; String typeString = null; if (el != null) { try { if (el.isJsonObject()) { JsonObject jsonObject = el.getAsJsonObject(); if (jsonObject.has(RuntimeTypeAdapterFactory.TYPE)) { typeString = jsonObject.get(RuntimeTypeAdapterFactory.TYPE).getAsString(); } } else if (el.isJsonPrimitive()) { typeString = el.getAsString(); } } catch (ClassCastException e) { } } // TODO: expand string to allow for builtin to be specified as ".SampleProbe" if (typeString != null) { try { Class<?> runtimeClass = Class.forName(typeString); if (baseClass.isAssignableFrom(runtimeClass)) { type = (Class<? extends T>) runtimeClass; } else { Log.w(LogUtil.TAG, "RuntimeTypeAdapter: Runtime class '" + typeString + "' is not assignable from default class '" + defaultClass.getName() + "'."); } } catch (ClassNotFoundException e) { Log.w(LogUtil.TAG, "RuntimeTypeAdapter: Runtime class '" + typeString + "' not found."); } } return type; } public static boolean isTypeInstatiable(Class<?> type) { int modifiers = type.getModifiers(); if (!(Modifier.isAbstract(modifiers) || Modifier.isInterface(modifiers))) { try { Constructor<?> noArgConstructor = type.getConstructor(); return Modifier.isPublic(noArgConstructor.getModifiers()); } catch (SecurityException e) { } catch (NoSuchMethodException e) { } } return false; } public static boolean isInstantiable(Class<?> type) { try { type.newInstance(); return true; } catch (IllegalAccessException e) { } catch (InstantiationException e) { } return false; } }