-
Notifications
You must be signed in to change notification settings - Fork 901
/
platforms.md
132 lines (100 loc) · 4.43 KB
/
platforms.md
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
# Platforms
A platform is a React Native package that enables writing and shipping React Native applications to a new target.
For example, React Native Windows is a platform, because it allows to run React Native apps on Windows. At the same time, React Native itself is also a platform - it allows to run React Native apps on Android, iOS, tvOS and Android TV.
Each platform can have an additional configuration for the CLI to enable bundling apps and linking packages for targets it provides.
## How does it work?
A platform can define the following `react-native.config.js` at the root:
```js
const ios = require('@react-native-community/cli-platform-ios');
const android = require('@react-native-community/cli-platform-android');
module.exports = {
platforms: {
ios: {
projectConfig: ios.projectConfig,
dependencyConfig: ios.dependencyConfig,
},
android: {
projectConfig: android.projectConfig,
dependencyConfig: android.dependencyConfig,
},
},
};
```
> The above config adds support for linking Android and iOS dependencies by the CLI as well as bundling code for these platforms. This config can be found in [React Native repository](https://github.com/facebook/react-native/blob/0.60-stable/react-native.config.js) from 0.60 version on.
At the startup, React Native CLI reads configuration from all dependencies listed in `package.json` and reduces them into a single configuration.
At the end, a map of available platforms is passed to the bundler (Metro) to make it aware of the platforms available. This allows APIs such as `Platform.select` and requiring files with platform extensions to work properly.
## Platform interface
```ts
type PlatformConfig<ProjectParams, ProjectConfig, DependencyConfig> = {
npmPackageName?: string;
projectConfig: (string, ProjectParams) => ?ProjectConfig;
dependencyConfig: (string, ProjectParams) => ?DependencyConfig;
};
```
### npmPackageName
Returns the name of the npm package that should be used as the source for react-native JS code for platforms that provide platform specific overrides to core JS files. This causes the default metro config to redirect imports of react-native to another package based when bundling for that platform. The package specified should provide a complete react-native implementation for that platform.
If this property is not specified, it is assumed that the code in core `react-native` works for the platform.
### projectConfig
Returns a project configuration for a given platform or `null`, when no project found.
First argument is a root folder where the project is located.
Second argument is everything that users defined under:
```js
module.exports = {
project: {
[yourPlatformKey]: {},
},
};
```
> Note: You may find this useful in order to alter the default behavior of your function. For example, on iOS, we find a `Podfile` by globbing the project files and taking the first match. There's a possibility we pick the wrong one in case the project has multiple `Podfile` files. In order to support this use-case, we have allowed users to define an iOS directory where the desired `Podfile` is located.
On Android and iOS, this function returns:
```ts
type IOSProjectConfig = {
sourceDir: string;
xcodeProject: {
name: string;
isWorkspace: boolean;
} | null;
watchModeCommandParams: string;
};
type AndroidProjectConfig = {
sourceDir: string;
appName: string;
packageName: string;
mainActivity: string;
dependencyConfiguration?: string;
watchModeCommandParams: string;
};
```
### dependencyConfig
Similar to [`projectConfig`](#projectconfig) above, but for a dependency of a project.
First argument is a path to a root folder of a dependency.
Second argument is everything that dependency authors defined under:
```js
module.exports = {
dependency: {
[yourPlatformKey]: {},
},
};
```
On Android and iOS, this function returns a dependency configuration for:
```ts
type IOSDependencyConfig = {
podspecPath: string;
version: string;
scriptPhases: Array<IOSScriptPhase>;
configurations: string[];
};
type AndroidDependencyConfig = {
sourceDir: string;
packageImportPath: string;
packageInstance: string;
dependencyConfiguration?: string;
buildTypes: string[];
libraryName?: string | null;
componentDescriptors?: string[] | null;
cmakeListsPath?: string | null;
cxxModuleCMakeListsModuleName? : string | null;
cxxModuleCMakeListsPath? : string | null;
cxxModuleHeaderName? : string | null;
};
```