上一篇我们简单的介绍了一下RoboGuice的使用(【三】注入框架RoboGuice使用:(Your
First Resource Injection)),今天我们来看下系统服务的使用注解的方法:

为了在Activity中系统服务使用注解，必须实现下面两个步骤:

①:创建继承RoboActivity的Activity

②:使用 @Inject来进行注解系统服务

以下我们来实现一个样例，和上一篇文章样例差点儿相同，我们须要进行实现系统服务。我们相同创建一个继承RoboActivity的Activity，然后使用@Inject进行注解服务，其它的操作就放心交给Roboguice帮你做吧。

class MyActivity extends RoboActivity {

    @Inject Vibrator vibrator;

    @Inject NotificationManager notificationManager;

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // we can use the instances directly!

        vibrator.vibrate(1000L); // RoboGuice took care of the getSystemService(VIBRATOR_SERVICE)

        notificationManager.cancelAll();

        // rest of your code

从上面能够看出来。RoboGuice知道怎么样依据系统服务来获取该引用对象，假设你想知道RoboGuice内部是怎么样进行绑定服务的能够查看一下DefaultRoboModule.java，以下就是该源码

package roboguice.config;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import roboguice.activity.RoboActivity;

import roboguice.event.EventManager;

import roboguice.event.ObservesTypeListener;

import roboguice.event.eventListener.factory.EventListenerThreadingDecorator;

import roboguice.fragment.FragmentUtil;

import roboguice.inject.AccountManagerProvider;

import roboguice.inject.AssetManagerProvider;

import roboguice.inject.ContentResolverProvider;

import roboguice.inject.ContextScope;

import roboguice.inject.ContextScopedSystemServiceProvider;

import roboguice.inject.ContextSingleton;

import roboguice.inject.ExtrasListener;

import roboguice.inject.HandlerProvider;

import roboguice.inject.InjectExtra;

import roboguice.inject.InjectPreference;

import roboguice.inject.InjectResource;

import roboguice.inject.NullProvider;

import roboguice.inject.PreferenceListener;

import roboguice.inject.ResourceListener;

import roboguice.inject.ResourcesProvider;

import roboguice.inject.SharedPreferencesProvider;

import roboguice.inject.SystemServiceProvider;

import roboguice.inject.ViewListener;

import roboguice.service.RoboService;

import roboguice.util.Ln;

import roboguice.util.LnImpl;

import roboguice.util.LnInterface;

import com.google.inject.Provider;

import com.google.inject.Provides;

import com.google.inject.Singleton;

import com.google.inject.AbstractModule;

import com.google.inject.matcher.Matchers;

import com.google.inject.name.Named;

import com.google.inject.name.Names;

import android.app.Activity;

import android.app.ActivityManager;

import android.app.AlarmManager;

import android.app.Application;

import android.app.DownloadManager;

import android.app.KeyguardManager;

import android.app.NotificationManager;

import android.app.SearchManager;

import android.app.Service;

import android.content.ContentResolver;

import android.content.Context;

import android.content.SharedPreferences;

import android.content.pm.PackageInfo;

import android.content.pm.PackageManager;

import android.content.res.AssetManager;

import android.content.res.Resources;

import android.hardware.SensorManager;

import android.location.LocationManager;

import android.media.AudioManager;

import android.net.ConnectivityManager;

import android.net.wifi.WifiManager;

import android.os.Build;

import android.os.Build.VERSION;

import android.os.Handler;

import android.os.PowerManager;

import android.os.Vibrator;

import android.provider.Settings;

import android.provider.Settings.Secure;

import android.telephony.TelephonyManager;

import android.util.Log;

import android.view.LayoutInflater;

import android.view.WindowManager;

import android.view.inputmethod.InputMethodManager;

/**

 * A Module that provides bindings and configuration to use Guice on Android.

 * Used by {@link roboguice.RoboGuice}.

 *

 * If you wish to add your own bindings, DO NOT subclass this class.  Instead, create a new

 * module that extends AbstractModule with your own bindings, then do something like the following:

 *

 * RoboGuice.setAppliationInjector( app, RoboGuice.DEFAULT_STAGE, Modules.override(RoboGuice.newDefaultRoboModule(app)).with(new MyModule() );

 *

 * @see com.google.inject.util.Modules#override(com.google.inject.Module...)

 * @see roboguice.RoboGuice#getOrCreateBaseApplicationInjector(android.app.Application, com.google.inject.Stage, com.google.inject.Module...)

 * @see roboguice.RoboGuice#newDefaultRoboModule(android.app.Application)

 * @see roboguice.RoboGuice#DEFAULT_STAGE

 *

 * @author Mike Burton

 */

@SuppressWarnings("PMD")

public class DefaultRoboModule extends AbstractModule {

    /**

     * Allows to retrieve the global, inter-context {@link EventManager}.

     * you MUST get the global {@link EventManager} either via a field annotated with {@code @Inject @Named}

     * or {@code getInjector.getInstance(key(EventManager.cass, Names.named())}.

     */

    public static final String GLOBAL_EVENT_MANAGER_NAME = "GlobalEventManager";

    @SuppressWarnings("rawtypes")

    private static Map<Class, String> mapSystemSericeClassToName = new HashMap<Class, String>();

    protected Application application;

    protected ContextScope contextScope;

    protected ResourceListener resourceListener;

    protected ViewListener viewListener;

    static {

        mapSystemSericeClassToName.put(LocationManager.class, Context.LOCATION_SERVICE);

        mapSystemSericeClassToName.put(WindowManager.class, Context.WINDOW_SERVICE);

        mapSystemSericeClassToName.put(ActivityManager.class, Context.ACTIVITY_SERVICE);

        mapSystemSericeClassToName.put(PowerManager.class, Context.POWER_SERVICE);

        mapSystemSericeClassToName.put(AlarmManager.class, Context.ALARM_SERVICE);

        mapSystemSericeClassToName.put(NotificationManager.class, Context.NOTIFICATION_SERVICE);

        mapSystemSericeClassToName.put(KeyguardManager.class, Context.KEYGUARD_SERVICE);

        mapSystemSericeClassToName.put(Vibrator.class, Context.VIBRATOR_SERVICE);

        mapSystemSericeClassToName.put(ConnectivityManager.class, Context.CONNECTIVITY_SERVICE);

        mapSystemSericeClassToName.put(WifiManager.class, Context.WIFI_SERVICE);

        mapSystemSericeClassToName.put(InputMethodManager.class, Context.INPUT_METHOD_SERVICE);

        mapSystemSericeClassToName.put(SensorManager.class, Context.SENSOR_SERVICE);

        mapSystemSericeClassToName.put(TelephonyManager.class, Context.TELEPHONY_SERVICE);

        mapSystemSericeClassToName.put(AudioManager.class, Context.AUDIO_SERVICE);

        if( VERSION.SDK_INT>=Build.VERSION_CODES.GINGERBREAD ) {

            mapSystemSericeClassToName.put(DownloadManager.class, Context.DOWNLOAD_SERVICE);

        }

    }

    public DefaultRoboModule(final Application application, ContextScope contextScope, ViewListener viewListener, ResourceListener resourceListener) {

        this.application = application;

        this.contextScope = contextScope;

        this.viewListener = viewListener;

        this.resourceListener = resourceListener;

    }

    /**

     * Configure this module to define Android related bindings.

     */

    @SuppressWarnings({ "rawtypes", "unchecked" })

    @Override

    protected void configure() {

        final Provider<Context> contextProvider = getProvider(Context.class);

        final EventListenerThreadingDecorator observerThreadingDecorator = new EventListenerThreadingDecorator();

        // Singletons

        bind(ViewListener.class).toInstance(viewListener);

        // ContextSingleton bindings

        bindScope(ContextSingleton.class, contextScope);

        //we need to super bind as we inject the scope by code only, not by annotations

        superbind(ContextScope.class).toInstance(contextScope);

        bind(AssetManager.class).toProvider(AssetManagerProvider.class);

        bind(Context.class).toProvider(NullProvider.<Context>instance()).in(ContextSingleton.class);

        bind(Activity.class).toProvider(NullProvider.<Activity>instance()).in(ContextSingleton.class);

        bind(RoboActivity.class).toProvider(NullProvider.<RoboActivity>instance()).in(ContextSingleton.class);

        bind(Service.class).toProvider(NullProvider.<Service>instance()).in(ContextSingleton.class);

        bind(RoboService.class).toProvider(NullProvider.<RoboService>instance()).in(ContextSingleton.class);

        // Sundry Android Classes

        bind(SharedPreferences.class).toProvider(SharedPreferencesProvider.class);

        bind(Resources.class).toProvider(ResourcesProvider.class);

        bind(ContentResolver.class).toProvider(ContentResolverProvider.class);

        bind(Application.class).toInstance(application);

        bind(EventListenerThreadingDecorator.class).toInstance(observerThreadingDecorator);

        bind(EventManager.class).annotatedWith(Names.named(GLOBAL_EVENT_MANAGER_NAME)).to(EventManager.class).asEagerSingleton();

        bind(Handler.class).toProvider(HandlerProvider.class);

        // System Services

        for( Entry<Class, String> entry : mapSystemSericeClassToName.entrySet() ) {

            bindSystemService(entry.getKey(), entry.getValue());

        }

        // System Services that must be scoped to current context

        bind(LayoutInflater.class).toProvider(new ContextScopedSystemServiceProvider<LayoutInflater>(contextProvider,Context.LAYOUT_INFLATER_SERVICE));

        bind(SearchManager.class).toProvider(new ContextScopedSystemServiceProvider<SearchManager>(contextProvider,Context.SEARCH_SERVICE));

        // Android Resources, Views and extras require special handling

        if( hasInjectionPointsForAnnotation(InjectResource.class) ) {

            bindListener(Matchers.any(), resourceListener);

        }

        if( hasInjectionPointsForAnnotation(InjectExtra.class) ) {

            final ExtrasListener extrasListener = new ExtrasListener(contextProvider);

            bindListener(Matchers.any(), extrasListener);

        }

        //should be bound only if we use InjectView or InjectFragment

        bindListener(Matchers.any(), viewListener);

        final PreferenceListener preferenceListener = new PreferenceListener(contextProvider,application);

        superbind(PreferenceListener.class).toInstance(preferenceListener);

        if( hasInjectionPointsForAnnotation(InjectPreference.class) ) {

            bindListener(Matchers.any(), preferenceListener);

        }

        //should always be bound as ContentViewListener relies on event system

        bindListener(Matchers.any(), new ObservesTypeListener(getProvider(EventManager.class), observerThreadingDecorator));

        requestInjection(observerThreadingDecorator);

        if( isInjectable(Ln.class)) {

            bind(LnInterface.class).to(LnImpl.class);

            //should this be placed in if statement ?

            requestStaticInjection(Ln.class);

        }

        bindDynamicBindings();

    }

    private <T> void bindSystemService(Class<T> c, String androidServiceName) {

        bind(c).toProvider(new SystemServiceProvider<T>(application, androidServiceName ));

    }

    @SuppressWarnings("unchecked")

    private void bindDynamicBindings() {

        // Compatibility library bindings

        if(FragmentUtil.hasSupport) {

            bind(FragmentUtil.supportFrag.fragmentManagerType()).toProvider(FragmentUtil.supportFrag.fragmentManagerProviderType());

        }

        if(FragmentUtil.hasNative) {

            bind(FragmentUtil.nativeFrag.fragmentManagerType()).toProvider(FragmentUtil.nativeFrag.fragmentManagerProviderType());

        }

        if( VERSION.SDK_INT>=Build.VERSION_CODES.ECLAIR ) {

            try {

                @SuppressWarnings("rawtypes")

                Class c = Class.forName("android.accounts.AccountManager");

                bind(c).toProvider(AccountManagerProvider.class);

            } catch( Throwable ex ) {

                Log.e(DefaultRoboModule.class.getName(), "Impossible to bind AccountManager", ex);

            }

        }

    }

    // ----------------------------------

    //  PROVIDER METHODS

    //  used for lazy bindings, when

    //  instance creation is costly.

    // ----------------------------------

    @Provides

    @Singleton

    public PackageInfo providesPackageInfo() {

        try {

            return application.getPackageManager().getPackageInfo(application.getPackageName(),0);

        } catch( PackageManager.NameNotFoundException e ) {

            throw new RuntimeException(e);

        }

    }

    @Provides

    @Named(Settings.Secure.ANDROID_ID)

    public String providesAndroidId() {

        String androidId = null;

        final ContentResolver contentResolver = application.getContentResolver();

        try {

            androidId = Secure.getString(contentResolver, Secure.ANDROID_ID);

        } catch( RuntimeException e) {

            // ignore Stub! errors for Secure.getString() when mocking in test cases since there's no way to mock static methods

            Log.e(DefaultRoboModule.class.getName(), "Impossible to get the android device Id. This may fail 'normally' when testing.", e);

        }

        if(!"".equals(androidId)) {

            return androidId;

        } else {

            throw new RuntimeException("No Android Id.");

        }

    }

}

【四】注入框架RoboGuice使用:(Your First System Service Injection)的更多相关文章

  1. 【九】注入框架RoboGuice使用:(Your First Injected Service and BroadcastReceiver)

    上一篇我们简单的介绍了一下RoboGuice的使用([八]注入框架RoboGuice使用:(Your First Injected Fragment)),今天我们来看下服务(Service)和广播接受 ...

  2. 【五】注入框架RoboGuice使用:(Your First POJO Injection)

    上一篇我们简单的介绍了一下RoboGuice的使用([四]注入框架RoboGuice使用:(Your First System Service Injection)),今天我们来看下普通Java对象的 ...

  3. 【十】注入框架RoboGuice使用:(Your First Testcase)

    上一篇我们简单的介绍了一下RoboGuice的使用([九]注入框架RoboGuice使用:(Your First Injected Service and BroadcastReceiver)),今天 ...

  4. 【十三】注入框架RoboGuice采用:(Logging via Ln)

    上一篇我们简单的介绍了一下RoboGuice的使用([十二]注入框架RoboGuice使用:(Your First Injected ContentProvider)),今天我们来看下Log日志使用. ...

  5. 【六】注入框架RoboGuice使用:(Singletons And ContextSingletons)

    上一篇我们简单的介绍了一下RoboGuice的使用([五]注入框架RoboGuice使用:(Your First POJO Injection)),今天我们来看下单例以及上下文单例(ContextSi ...

  6. 【十一年】注入框架RoboGuice采用:(Your First Injection into a Custom View class)

    上一篇我们简单的介绍了一下RoboGuice的使用([十]注入框架RoboGuice使用:(Your First Testcase)),今天我们来看下自己定义View的注入(Custom View). ...

  7. 【七】注入框架RoboGuice使用:(Your First Custom Binding)

    上一篇我们简单的介绍了一下RoboGuice的使用([六]注入框架RoboGuice使用:(Singletons And ContextSingletons)),今天我们来看下自己定义绑定(bindi ...

  8. 【三】注入框架RoboGuice使用:(Your First Resource Injection)

    上一篇我们简单的介绍了一下RoboGuice的使用([二]注入框架RoboGuice使用:(Your First View Injection)),今天我们来看下资源文件的使用注解的方法: 为了在Ac ...

  9. 【八】注入框架RoboGuice使用:(Your First Injected Fragment)

        上一篇我们简单的介绍了一下RoboGuice的使用([七]注入框架RoboGuice使用:(Your First Custom Binding)),今天我们来看下fragment的注解     ...

随机推荐

  1. python异常处理try,except,else,finally,raise

    先看下else的使用: try: ... exception: ... else: ... 只有在try中没有发生任何异常,所有代码完全成功的情况下才会转入else 再看下finally: final ...

  2. Binary Tree Level Order Traversal II --leetcode C++

    考察点 广度优先遍历--层次遍历 STL内容器的用法 广度优先遍历的时候,首先应该想到的就是借助于队列.还需要在遍历下一层之前保存当前层节点的数量 代码很简单: class Solution { pu ...

  3. lua协程并发下载简单测试

    下载8个1m大小文件,测试五次分别耗时12.038s,10.316s,8.955s,11.275s,9.499s(lua代码实现如下) require "socket" --hos ...

  4. 移动开发语言Swift

    苹果公布了全新的编程语言Swift,Swift继承了Objective-C语言特性,并从Python和Java Script中长处,使Swift更易读.未来swift编程语言的会特大广大的使用 Swi ...

  5. redis研究笔记

    本文链接:http://blog.csdn.net/u012150179/article/details/38077851 一. redis Redis is an in-memory databas ...

  6. 打造自己的sublime text

    博主今天正在了解学习LESS,在找相关资源的过程中,发现自己的sublime text和别人差别有点大,突然脑海中一股逼格的气息油然而生,于是查找了相关资料,并打造了一下风格. 下面开始正文. 首先是 ...

  7. LeetCode 二叉树的最小深度

    计算二叉树的最小深度.最小深度定义为从root到叶子节点的最小路径. public class Solution { public int run(TreeNode root) { if(root = ...

  8. Linux解压缩总结

    看文件名的后缀名,不同的后缀的文件解压和压缩的命令都不一样总结如下: *.tar 用 tar –xvf 解压 *.gz 用 gzip -d或者gunzip 解压 *.tar.gz和*.tgz 用 ta ...

  9. centos6.5配置163的yum源

    CentOS系统自带的更新源的速度实在是慢,为了让CentOS6使用速度更快的YUM更新源,可以选择163(网易)的更新源. 1.下载repo文件 wget http://mirrors.163.co ...

  10. 羊和汽车问题（或s三门问题（Monty Hall problem）亦称为蒙提霍尔问题）

    三门问题(Monty Hall problem)亦称为蒙提霍尔问题.蒙特霍问题或蒙提霍尔悖论,大致出自美国的电视游戏节目Let's Make a Deal.问题名字来自该节目的主持人蒙提·霍尔(Mon ...