If you think the Android project zxingcapturemod listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
Java Source Code
/*
* Copyright (C) 2012 ZXing authors//fromwww.java2s.com
*
* Licensed 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 com.google.zxing.client.android.common;
import android.os.Build;
import android.util.Log;
import java.lang.reflect.InvocationTargetException;
import java.util.Collections;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* <p>Sometimes the application wants to access advanced functionality exposed by Android APIs that are only available
* in later versions of the platform. While {@code Build.VERSION} can be used to determine the device's API level
* and alter behavior accordingly, and it is possible to write code that uses both old and new APIs selectively,
* such code would fail to load on older devices that do not have the new API methods.</p>
*
* <p>It is necessary to only load classes that use newer APIs than the device may support after the app
* has checked the API level. This requires reflection, loading one of several implementations based on the
* API level.</p>
*
* <p>This class manages that process. Subclasses of this class manage access to implementations of a given interface
* in an API-level-aware way. Subclasses implementation classes <em>by name</em>, and the minimum API level that
* the implementation is compatible with. They also provide a default implementation.</p>
*
* <p>At runtime an appropriate implementation is then chosen, instantiated and returned from {@link #build()}.</p>
*
* @param <T> the interface which managed implementations implement
*/publicabstractclass PlatformSupportManager<T> {
privatestaticfinal String TAG = PlatformSupportManager.class.getSimpleName();
privatefinal Class<T> managedInterface;
privatefinal T defaultImplementation;
privatefinal SortedMap<Integer,String> implementations;
protected PlatformSupportManager(Class<T> managedInterface, T defaultImplementation) {
if (!managedInterface.isInterface()) {
thrownew IllegalArgumentException();
}
if (!managedInterface.isInstance(defaultImplementation)) {
thrownew IllegalArgumentException();
}
this.managedInterface = managedInterface;
this.defaultImplementation = defaultImplementation;
this.implementations = new TreeMap<Integer,String>(Collections.reverseOrder());
}
protectedvoid addImplementationClass(int minVersion, String className) {
implementations.put(minVersion, className);
}
public T build() {
for (Integer minVersion : implementations.keySet()) {
if (Build.VERSION.SDK_INT >= minVersion) {
String className = implementations.get(minVersion);
try {
Class<? extends T> clazz = Class.forName(className).asSubclass(managedInterface);
Log.i(TAG, "Using implementation " + clazz + " of " + managedInterface + " for SDK " + minVersion);
return clazz.getConstructor().newInstance();
} catch (ClassNotFoundException cnfe) {
Log.w(TAG, cnfe);
} catch (IllegalAccessException iae) {
Log.w(TAG, iae);
} catch (InstantiationException ie) {
Log.w(TAG, ie);
} catch (NoSuchMethodException nsme) {
Log.w(TAG, nsme);
} catch (InvocationTargetException ite) {
Log.w(TAG, ite);
}
}
}
Log.i(TAG, "Using default implementation " + defaultImplementation.getClass() + " of " + managedInterface);
return defaultImplementation;
}
}