org.androidannotations.annotations.AfterInject Java Examples

@AfterInject
protected void init() {
    if (DEBUG) {
        Log.i(TAG, "service started");
    }

    sampleTime = Configuration.with(this).minimumGpsTimeInMilliseconds();
    sampleDistance = Configuration.with(this).minimumGpsDistanceInMeters();

    try {
        locationManager.requestLocationUpdates(LocationManager.PASSIVE_PROVIDER,
                sampleTime,
                sampleDistance,
                gpsMonitor.this);
    } catch (SecurityException ex) {
        if(DEBUG) {
            Log.w(TAG, "init()", ex);
        }
    }

    Configuration.with(this).register(this);
}
 

@AfterInject
void init() {
    resolvers.put(StorageDomain.class, storageDomainIntentResolver);
    resolvers.put(Host.class, hostIntentResolver);
    resolvers.put(Vm.class, vmIntentResolver);
    resolvers.put(Snapshot.class, snapshotIntentResolver);
}
 

@AfterInject
void initContentProviderClient() {
    final ContentResolver contentResolver = context.getContentResolver();
    contentClient = contentResolver.acquireContentProviderClient(OVirtContract.BASE_CONTENT_URI);

    SqlBrite sqlBrite = new SqlBrite.Builder().build();
    // TODO possibly refactor to use sqlBrite.wrapDatabaseHelper(), but all queries must use SqlBrite
    briteResolver = sqlBrite.wrapContentProvider(contentResolver, Schedulers.io());
}
 

@AfterInject
void init() {
    for (final UriDependency dependency : UriMatcher.getUriDependencies()) {
        context.getContentResolver().registerContentObserver(dependency.observe, true, new ContentObserver(null) {
            @Override
            public void onChange(boolean selfChange) {
                super.onChange(selfChange);
                context.getContentResolver().notifyChange(dependency.notify, null);
            }
        });
    }
}
 

@AfterInject
public void init() {
    if (holder.getCurrentOverlay() == null) {
        View overlayView = new OverlayView(this);
        windowManager.addView(overlayView, OverlayView.createLayoutParams(retrieveStatusBarHeight() + SAFETY_MARGIN));
        holder.setCurrentOverlay(overlayView);
    }
    holder.hideView();
}
 

@AfterInject
void setupBuilder() {
	Intent gameActivityIntent = GameActivity_.intent(context).action(Actions.ACTION_RESUME_GAME).get();
	PendingIntent gameActivityPendingIntent = PendingIntent.getActivity(context, 0, gameActivityIntent, 0);

	builder = new NotificationCompat.Builder(context, context.getString(R.string.notification_channel_id))
			.setSmallIcon(R.drawable.icon)
			.setContentTitle(title)
			.setContentIntent(gameActivityPendingIntent)
			.setPriority(NotificationCompat.PRIORITY_DEFAULT);
}
 

@AfterInject
void initialize() {
    sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
}
 

@AfterInject
public void init() {
    bus.register(driveClient);
}
 

@AfterInject
public void setVm() {
    if (!StringUtils.isEmpty(vmId)) {
        currentVm = providerFacade.query(Vm.class).id(vmId).first();
    }
}
 

@AfterInject
void init() {
    // refresh account even though we add listener later
    Set<MovirtAccount> accounts = refreshAccounts();

    // load active account from preferences
    final StoredActiveSelection storedSelection = commonSharedPreferencesHelper.getActiveSelection();
    for (MovirtAccount account : accounts) {
        if (account.getId().equals(storedSelection.accountId)) {
            ACTIVE_SELECTION.onNext(new ActiveSelection(account, storedSelection.clusterId));
        }
    }

    Observable.combineLatest(providerFacade.query(Cluster.class).asObservable(),
            ACTIVE_SELECTION.distinctUntilChanged(), SelectionClusters::new)
            .subscribeOn(Schedulers.computation())
            .subscribe(selectionClusters -> {
                ActiveSelection selection = selectionClusters.getActiveSelection();
                // preserve active one in preferences
                commonSharedPreferencesHelper.setActiveSelection(new StoredActiveSelection(selection));

                if (selection.isCluster()) {
                    // check if cluster name changed
                    for (Cluster cluster : selectionClusters.getClusters()) {
                        if (selection.isCluster(cluster.getId())) {
                            if (!selection.isClusterName(cluster.getName())) {
                                ACTIVE_SELECTION.onNext(new ActiveSelection(selection.getAccount(),
                                        selection.getClusterId(), cluster.getName()));
                            }
                            return;
                        }
                    }
                    ACTIVE_SELECTION.onNext(ActiveSelection.ALL_ACTIVE); // cluster deleted
                }
            });

    ALL_ACCOUNTS.map(allAccounts -> accounts.size())
            .distinctUntilChanged()
            .filter(size -> size == 0) // detect only change when all deleted, it is set to true on account creation
            .subscribeOn(Schedulers.computation())
            .subscribe(accountSize -> commonSharedPreferencesHelper.setFirstAccountConfigured(false));

    Observable.combineLatest(REMOVED_ACCOUNT, ACTIVE_SELECTION, SelectedAccountRemoved::new)
            .filter(SelectedAccountRemoved::isRemoved)
            .subscribeOn(Schedulers.computation())
            .subscribe(removed -> ACTIVE_SELECTION.onNext(ActiveSelection.ALL_ACTIVE));

    // listen for system changes on accounts
    accountManagerHelper.addOnAccountsUpdatedListener(accs -> ALL_ACCOUNTS.onNext(AllAccounts.newInstance(accs)));
}
 

@AfterInject
void init(){
    wheelList = new ArrayList<ParamWidget>();
    UIHelper.getDialog(R.string.tips_loading_params).show();
    loadData();
}
 

@AfterInject
void initDialog(){
    UIHelper.buildDialog(this, this);
    cacheHelper = new CacheHelper(this);
}
 

@AfterInject
void init(){
    mContext = this;
}
 

@AfterInject
void initDialog(){
    UIHelper.buildDialog(getActivity(), this);
}
 

@AfterInject
void init(){
    ctx = getSherlockActivity();
    setTitle(R.string.title_card);
    tips_empty = R.string.tips_card_null;
}
 

@AfterInject
void initAfterInject(){
    setQueryTarget(QUERY_FOR_LIBRARY);
}
 

@AfterInject
protected void init() {
    database = SamplerDatabase.getInstance(this);
    wifiReceiver = new WifiReceiver(wifiManager, this);
}
 

@AfterInject
protected void setFragmentActivity() {
    fragmentActivity = getFragmentActivity();
}
 

@AfterInject
void init() {
    uiHandler.setFragment(this);
    poiHandler.setFragment(this);
}
 

@AfterInject
protected void init() {
    display = windowManager.getDefaultDisplay();
}
 

@AfterInject
void addInterceptors() {
    setInterceptors(Collections.<ClientHttpRequestInterceptor>singletonList(basicAuthorizationInterceptor));
}
 

@AfterInject
void adjustRestService() {
    restServiceRegistry.adjustRestService(incomingDeliveryRestService, "MOS_ERP_INVENTORY_MODULE");
}
 

@AfterInject
void adjustRestService() {
    restServiceRegistry.adjustRestService(inventoryTransferRestService, "MOS_ERP_INVENTORY_MODULE");
}
 

@AfterInject
void adjustRestService() {
    restServiceRegistry.adjustRestService(inventoryItemRestService, "MOS_ERP_INVENTORY_MODULE");
}
 

@AfterInject
void adjustRestService() {
    restServiceRegistry.adjustRestService(outgoingDeliveryRestService, "MOS_ERP_INVENTORY_MODULE");
}
 

@AfterInject
protected void afterBaseInject() {
    openDatabase();
}
 

@AfterInject
void onAfterInjectFinished() {
    networkErrorHandler.setSnackBarBackgroundColor(snackBarColor);
}
 

@AfterInject
void onAfterInjectFinished() {
    openWeatherAPI = initRestAdapter(ENDPOINT, OpenWeatherAPI.class);
}
 

@AfterInject
public void init() {
    bus.register(this);
}
 

@AfterInject
public void init() {

}