1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/*
* Copyright (C) 2017 The Android Open Source Project
*
* 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 android.app;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.BroadcastReceiver;
import android.content.ContentProvider;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
/**
* Interface used to control the instantiation of manifest elements.
*
* @see #instantiateApplication
* @see #instantiateActivity
* @see #instantiateClassLoader
* @see #instantiateService
* @see #instantiateReceiver
* @see #instantiateProvider
*/
public class AppComponentFactory {
/**
* Selects the class loader which will be used by the platform to instantiate app components.
* <p>
* The default implementation of this method returns the {@code cl} parameter unchanged.
* Applications can override this method to set up a custom class loader or a custom class
* loader hierarchy and return it to the platform.
* <p>
* The method is a hook invoked before any application components are instantiated or the
* application Context is initialized. It is intended to allow the application's classes to
* be loaded from a different source than the base/split APK(s).
* <p>
* The default class loader {@code cl} is created by the platform and used to load the
* application's base or split APK(s). Its parent is typically the boot class loader, unless
* running under instrumentation. Its classname is configurable using the
* {@link android.R.attr#classLoader} manifest attribute.
*
* @param cl The default class loader created by the platform.
* @param aInfo Information about the application being loaded.
*/
public @NonNull ClassLoader instantiateClassLoader(@NonNull ClassLoader cl,
@NonNull ApplicationInfo aInfo) {
return cl;
}
/**
* Allows application to override the creation of the application object. This can be used to
* perform things such as dependency injection or class loader changes to these
* classes.
* <p>
* This method is only intended to provide a hook for instantiation. It does not provide
* earlier access to the Application object. The returned object will not be initialized
* as a Context yet and should not be used to interact with other android APIs.
*
* @param cl The default classloader to use for instantiation.
* @param className The class to be instantiated.
*/
public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,
@NonNull String className)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Application) cl.loadClass(className).newInstance();
}
/**
* Allows application to override the creation of activities. This can be used to
* perform things such as dependency injection or class loader changes to these
* classes.
* <p>
* This method is only intended to provide a hook for instantiation. It does not provide
* earlier access to the Activity object. The returned object will not be initialized
* as a Context yet and should not be used to interact with other android APIs.
*
* @param cl The default classloader to use for instantiation.
* @param className The class to be instantiated.
* @param intent Intent creating the class.
*/
public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
@Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Activity) cl.loadClass(className).newInstance();
}
/**
* Allows application to override the creation of receivers. This can be used to
* perform things such as dependency injection or class loader changes to these
* classes.
*
* @param cl The default classloader to use for instantiation.
* @param className The class to be instantiated.
* @param intent Intent creating the class.
*/
public @NonNull BroadcastReceiver instantiateReceiver(@NonNull ClassLoader cl,
@NonNull String className, @Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (BroadcastReceiver) cl.loadClass(className).newInstance();
}
/**
* Allows application to override the creation of services. This can be used to
* perform things such as dependency injection or class loader changes to these
* classes.
* <p>
* This method is only intended to provide a hook for instantiation. It does not provide
* earlier access to the Service object. The returned object will not be initialized
* as a Context yet and should not be used to interact with other android APIs.
*
* @param cl The default classloader to use for instantiation.
* @param className The class to be instantiated.
* @param intent Intent creating the class.
*/
public @NonNull Service instantiateService(@NonNull ClassLoader cl,
@NonNull String className, @Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Service) cl.loadClass(className).newInstance();
}
/**
* Allows application to override the creation of providers. This can be used to
* perform things such as dependency injection or class loader changes to these
* classes.
* <p>
* This method is only intended to provide a hook for instantiation. It does not provide
* earlier access to the ContentProvider object. The returned object will not be initialized
* with a Context yet and should not be used to interact with other android APIs.
*
* @param cl The default classloader to use for instantiation.
* @param className The class to be instantiated.
*/
public @NonNull ContentProvider instantiateProvider(@NonNull ClassLoader cl,
@NonNull String className)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (ContentProvider) cl.loadClass(className).newInstance();
}
/**
* @hide
*/
public static final AppComponentFactory DEFAULT = new AppComponentFactory();
}
|
