GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/vscode-react-native

Public

mirrored fromhttps://github.com/microsoft/vscode-react-nativeAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
c0b32993595df760282a903082cf37d59de18ea8

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

vscode-react-native/src/extension/android

src/extension/android/androidPlatform.ts

235lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation. All rights reserved.
2// Licensed under the MIT license. See LICENSE file in the project root for details.
3
4import * as Q from "q";
5import * as semver from "semver";
6
7import {GeneralMobilePlatform, MobilePlatformDeps } from "../generalMobilePlatform";
8import {IAndroidRunOptions} from "../launchArgs";
9import {AdbHelper, AndroidAPILevel, IDevice} from "./adb";
10import {Package} from "../../common/node/package";
11import {PromiseUtil} from "../../common/node/promise";
12import {PackageNameResolver} from "./packageNameResolver";
13import {OutputVerifier, PatternToFailure} from "../../common/outputVerifier";
14import {TelemetryHelper} from "../../common/telemetryHelper";
15import {CommandExecutor} from "../../common/commandExecutor";
16import {LogCatMonitor} from "./logCatMonitor";
17import {ReactNativeProjectHelper} from "../../common/reactNativeProjectHelper";
18
19/**
20 * Android specific platform implementation for debugging RN applications.
21 */
22export class AndroidPlatform extends GeneralMobilePlatform {
23 private static MULTIPLE_DEVICES_ERROR = "error: more than one device/emulator";
24
25 // We should add the common Android build/run errors we find to this list
26 private static RUN_ANDROID_FAILURE_PATTERNS: PatternToFailure[] = [{
27 pattern: "Failed to install on any devices",
28 message: "Could not install the app on any available device. Make sure you have a correctly"
29 + " configured device or emulator running. See https://facebook.github.io/react-native/docs/android-setup.html",
30 }, {
31 pattern: "com.android.ddmlib.ShellCommandUnresponsiveException",
32 message: "An Android shell command timed-out. Please retry the operation.",
33 }, {
34 pattern: "Android project not found",
35 message: "Android project not found.",
36
37 }, {
38 pattern: "error: more than one device/emulator",
39 message: AndroidPlatform.MULTIPLE_DEVICES_ERROR,
40 }, {
41 pattern: /^Error: Activity class \{.*\} does not exist\.$/m,
42 message: "Failed to launch the specified activity. Try running application manually and "
43 + "start debugging using 'Attach to packager' launch configuration.",
44 }];
45
46 private static RUN_ANDROID_SUCCESS_PATTERNS: string[] = ["BUILD SUCCESSFUL", "Starting the app", "Starting: Intent"];
47
48 private debugTarget: IDevice;
49 private devices: IDevice[];
50 private packageName: string;
51 private logCatMonitor: LogCatMonitor | null = null;
52
53 private needsToLaunchApps: boolean = false;
54 public static showDevMenu(deviceId?: string): Q.Promise<void> {
55 return AdbHelper.showDevMenu(deviceId);
56 }
57 public static reloadApp(deviceId?: string): Q.Promise<void> {
58 return AdbHelper.reloadApp(deviceId);
59 }
60
61 // We set remoteExtension = null so that if there is an instance of androidPlatform that wants to have it's custom remoteExtension it can. This is specifically useful for tests.
62 constructor(protected runOptions: IAndroidRunOptions, platformDeps: MobilePlatformDeps = {}) {
63 super(runOptions, platformDeps);
64
65 if (this.runOptions.target === AndroidPlatform.simulatorString ||
66 this.runOptions.target === AndroidPlatform.deviceString) {
67
68 const message = `Target ${this.runOptions.target} is not supported for Android ` +
69 "platform. If you want to use particular device or simulator for launching " +
70 "Android app, please specify device id (as in 'adb devices' output) instead.";
71
72 this.logger.warning(message);
73 delete this.runOptions.target;
74 }
75 }
76
77 public runApp(shouldLaunchInAllDevices: boolean = false): Q.Promise<void> {
78 return TelemetryHelper.generate("AndroidPlatform.runApp", () => {
79 const runArguments = this.getRunArgument();
80 const env = this.getEnvArgument();
81
82 return ReactNativeProjectHelper.getReactNativeVersion(this.runOptions.projectRoot)
83 .then(version => {
84 if (semver.gte(version, AndroidPlatform.NO_PACKAGER_VERSION)) {
85 runArguments.push("--no-packager");
86 }
87
88 const runAndroidSpawn = new CommandExecutor(this.projectPath, this.logger).spawnReactCommand("run-android", runArguments, {env});
89 const output = new OutputVerifier(
90 () =>
91 Q(AndroidPlatform.RUN_ANDROID_SUCCESS_PATTERNS),
92 () =>
93 Q(AndroidPlatform.RUN_ANDROID_FAILURE_PATTERNS)).process(runAndroidSpawn);
94
95 return output
96 .finally(() => {
97 return this.initializeTargetDevicesAndPackageName();
98 }).then(() => [this.debugTarget], reason => {
99 if (reason.message === AndroidPlatform.MULTIPLE_DEVICES_ERROR && this.devices.length > 1 && this.debugTarget) {
100 /* If it failed due to multiple devices, we'll apply this workaround to make it work anyways */
101 this.needsToLaunchApps = true;
102 return shouldLaunchInAllDevices
103 ? AdbHelper.getOnlineDevices()
104 : Q([this.debugTarget]);
105 } else {
106 return Q.reject<IDevice[]>(reason);
107 }
108 }).then(devices => {
109 return new PromiseUtil().forEach(devices, device => {
110 return this.launchAppWithADBReverseAndLogCat(device);
111 });
112 });
113 });
114 });
115 }
116
117 public enableJSDebuggingMode(): Q.Promise<void> {
118 return AdbHelper.switchDebugMode(this.runOptions.projectRoot, this.packageName, true, this.debugTarget.id);
119 }
120
121 public disableJSDebuggingMode(): Q.Promise<void> {
122 return AdbHelper.switchDebugMode(this.runOptions.projectRoot, this.packageName, false, this.debugTarget.id);
123 }
124
125 public prewarmBundleCache(): Q.Promise<void> {
126 return this.packager.prewarmBundleCache("android");
127 }
128
129 public getRunArgument(): string[] {
130 let runArguments: string[] = [];
131
132 if (this.runOptions.runArguments && this.runOptions.runArguments.length > 0) {
133 runArguments = this.runOptions.runArguments;
134 } else {
135 if (this.runOptions.variant) {
136 runArguments.push("--variant", this.runOptions.variant);
137 }
138 if (this.runOptions.target) {
139 runArguments.push("--deviceId", this.runOptions.target);
140 }
141 }
142
143 return runArguments;
144 }
145
146 private initializeTargetDevicesAndPackageName(): Q.Promise<void> {
147 return AdbHelper.getConnectedDevices().then(devices => {
148 this.devices = devices;
149 this.debugTarget = this.getTargetEmulator(devices);
150 return this.getPackageName().then(packageName => {
151 this.packageName = packageName;
152 });
153 });
154 }
155
156 private launchAppWithADBReverseAndLogCat(device: IDevice): Q.Promise<void> {
157 return Q({})
158 .then(() => {
159 return this.configureADBReverseWhenApplicable(device);
160 }).then(() => {
161 return this.needsToLaunchApps
162 ? AdbHelper.launchApp(this.runOptions.projectRoot, this.packageName, device.id)
163 : Q<void>(void 0);
164 }).then(() => {
165 return this.startMonitoringLogCat(device, this.runOptions.logCatArguments);
166 });
167 }
168
169 private configureADBReverseWhenApplicable(device: IDevice): Q.Promise<void> {
170 return Q({}) // For other emulators and devices we try to enable adb reverse
171 .then(() => AdbHelper.apiVersion(device.id))
172 .then(apiVersion => {
173 if (apiVersion >= AndroidAPILevel.LOLLIPOP) { // If we support adb reverse
174 return AdbHelper.reverseAdb(device.id, Number( this.runOptions.packagerPort));
175 } else {
176 this.logger.warning(`Device ${device.id} supports only API Level ${apiVersion}. `
177 + `Level ${AndroidAPILevel.LOLLIPOP} is needed to support port forwarding via adb reverse. `
178 + "For debugging to work you'll need <Shake or press menu button> for the dev menu, "
179 + "go into <Dev Settings> and configure <Debug Server host & port for Device> to be "
180 + "an IP address of your computer that the Device can reach. More info at: "
181 + "https://facebook.github.io/react-native/docs/debugging.html#debugging-react-native-apps");
182 return void 0;
183 }
184 });
185 }
186
187 private getPackageName(): Q.Promise<string> {
188 return new Package(this.runOptions.projectRoot).name().then(appName =>
189 new PackageNameResolver(appName).resolvePackageName(this.runOptions.projectRoot));
190 }
191
192 /**
193 * Returns the target emulator, using the following logic:
194 * * If an emulator is specified and it is connected, use that one.
195 * * Otherwise, use the first one in the list.
196 */
197 private getTargetEmulator(devices: IDevice[]): IDevice {
198 let activeFilterFunction = (device: IDevice) => {
199 return device.isOnline;
200 };
201
202 let targetFilterFunction = (device: IDevice) => {
203 return device.id === this.runOptions.target && activeFilterFunction(device);
204 };
205
206 if (this.runOptions && this.runOptions.target && devices) {
207 /* check if the specified target is active */
208 const targetDevice = devices.find(targetFilterFunction);
209 if (targetDevice) {
210 return targetDevice;
211 }
212 }
213
214 /* return the first active device in the list */
215 let activeDevices = devices && devices.filter(activeFilterFunction);
216 return activeDevices && activeDevices[0];
217 }
218
219 private startMonitoringLogCat(device: IDevice, logCatArguments: string): void {
220 this.stopMonitoringLogCat(); // Stop previous logcat monitor if it's running
221
222 // this.logCatMonitor can be mutated, so we store it locally too
223 this.logCatMonitor = new LogCatMonitor(device.id, logCatArguments);
224 this.logCatMonitor.start() // The LogCat will continue running forever, so we don't wait for it
225 .catch(error => this.logger.warning("Error while monitoring LogCat", error)) // The LogCatMonitor failing won't stop the debugging experience
226 .done();
227 }
228
229 private stopMonitoringLogCat(): void {
230 if (this.logCatMonitor) {
231 this.logCatMonitor.dispose();
232 this.logCatMonitor = null;
233 }
234 }
235}
236