/**
* Called from native code to share a surface texture with another child process. Through using
* the callback object the browser is used as a proxy to route the call to the correct process.
*
* @param pid Process handle of the child process to share the SurfaceTexture with.
* @param surfaceObject The Surface or SurfaceTexture to share with the other child process.
* @param primaryID Used to route the call to the correct client instance.
* @param secondaryID Used to route the call to the correct client instance.
*/
@SuppressWarnings("unused")
@CalledByNative
private void establishSurfaceTexturePeer(
int pid, Object surfaceObject, int primaryID, int secondaryID) {
if (mCallback == null) {
Log.e(TAG, "No callback interface has been provided.");
return;
}
Surface surface = null;
boolean needRelease = false;
if (surfaceObject instanceof Surface) {
surface = (Surface) surfaceObject;
} else if (surfaceObject instanceof SurfaceTexture) {
surface = new Surface((SurfaceTexture) surfaceObject);
needRelease = true;
} else {
Log.e(TAG, "Not a valid surfaceObject: %s", surfaceObject);
return;
}
try {
mCallback.establishSurfacePeer(pid, surface, primaryID, secondaryID);
} catch (RemoteException e) {
Log.e(TAG, "Unable to call establishSurfaceTexturePeer: %s", e);
return;
} finally {
if (needRelease) {
surface.release();
}
}
}
@Override
protected boolean isStartedUpCorrectly(Intent intent) {
int tabId = ActivityDelegate.getTabIdFromIntent(getIntent());
// Fire a MAIN Intent to send the user back through ChromeLauncherActivity.
Log.e(TAG, "User shouldn't be here. Sending back to ChromeLauncherActivity.");
// Try to bring this tab forward after migration.
Intent tabbedIntent = null;
if (tabId != Tab.INVALID_TAB_ID) tabbedIntent = Tab.createBringTabToFrontIntent(tabId);
if (tabbedIntent == null) {
tabbedIntent = new Intent(Intent.ACTION_MAIN);
tabbedIntent.setPackage(getPackageName());
}
// Launch the other Activity in its own task so it stays when this one finishes.
tabbedIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
tabbedIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT);
startActivity(tabbedIntent);
overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
Log.e(TAG, "Discarding Intent: Tab = " + tabId);
return false;
}
/**
* Restores the encryption key from the given Bundle. Expected to be called when an Activity is
* being restored after being killed in the background. If the Activity was explicitly killed by
* the user, Android gives no Bundle (and therefore no key).
*
* @param savedInstanceState Bundle containing the Activity's previous state. Null if the user
* explicitly killed the Activity.
* @return True if the data was restored successfully from the Bundle, or if the CipherData in use
* matches the Bundle contents.
*/
public boolean restoreFromBundle(Bundle savedInstanceState) {
if (savedInstanceState == null) return false;
byte[] wrappedKey = savedInstanceState.getByteArray(BUNDLE_KEY);
byte[] iv = savedInstanceState.getByteArray(BUNDLE_IV);
if (wrappedKey == null || iv == null) return false;
try {
Key bundledKey = new SecretKeySpec(wrappedKey, "AES");
synchronized (mDataLock) {
if (mData == null) {
mData = new CipherData(bundledKey, iv);
return true;
} else if (mData.key.equals(bundledKey) && Arrays.equals(mData.iv, iv)) {
return true;
} else {
Log.e(TAG, "Attempted to restore different cipher data.");
}
}
} catch (IllegalArgumentException e) {
Log.e(TAG, "Error in restoring the key from the bundle.");
}
return false;
}
/** Registers this object with the location service. */
private void registerForLocationUpdates(boolean enableHighAccuracy) {
ensureLocationManagerCreated();
if (usePassiveOneShotLocation()) return;
assert !mIsRunning;
mIsRunning = true;
// We're running on the main thread. The C++ side is responsible to
// bounce notifications to the Geolocation thread as they arrive in the mainLooper.
try {
Criteria criteria = new Criteria();
if (enableHighAccuracy) criteria.setAccuracy(Criteria.ACCURACY_FINE);
mLocationManager.requestLocationUpdates(
0, 0, criteria, this, ThreadUtils.getUiThreadLooper());
} catch (SecurityException e) {
Log.e(
TAG,
"Caught security exception while registering for location updates "
+ "from the system. The application does not have sufficient geolocation "
+ "permissions.");
unregisterFromLocationUpdates();
// Propagate an error to JavaScript, this can happen in case of WebView
// when the embedding app does not have sufficient permissions.
LocationProviderAdapter.newErrorAvailable(
"application does not have sufficient " + "geolocation permissions.");
} catch (IllegalArgumentException e) {
Log.e(TAG, "Caught IllegalArgumentException registering for location updates.");
unregisterFromLocationUpdates();
assert false;
}
}
@CalledByNative
public void startCapture() {
Log.d(TAG, "startCapture");
synchronized (mCaptureStateLock) {
if (mCaptureState != CaptureState.ALLOWED) {
Log.e(TAG, "startCapture() invoked without user permission.");
return;
}
}
mMediaProjection = mMediaProjectionManager.getMediaProjection(mResultCode, mResultData);
if (mMediaProjection == null) {
Log.e(TAG, "mMediaProjection is null");
return;
}
mMediaProjection.registerCallback(new MediaProjectionCallback(), null);
mThread = new HandlerThread("ScreenCapture");
mThread.start();
mBackgroundHandler = new Handler(mThread.getLooper());
// On Android M and above, YUV420 is prefered. Some Android L devices will silently
// fail with YUV420, so keep with RGBA_8888 on L.
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
mFormat = PixelFormat.RGBA_8888;
} else {
mFormat = ImageFormat.YUV_420_888;
}
maybeDoRotation();
createImageReaderWithFormat();
createVirtualDisplay();
changeCaptureStateAndNotify(CaptureState.STARTED);
}
private void waitForDebuggerIfNeeded() {
if (CommandLine.getInstance().hasSwitch(BaseSwitches.WAIT_FOR_JAVA_DEBUGGER)) {
Log.e(TAG, "Waiting for Java debugger to connect...");
android.os.Debug.waitForDebugger();
Log.e(TAG, "Java debugger connected. Resuming execution.");
}
}
/**
* Return the OpenSSLEngine object corresponding to a given PrivateKey object.
*
* <p>This shall only be used for Android 4.1 to work around a platform bug. See
* https://crbug.com/381465.
*
* @param privateKey The PrivateKey handle.
* @return The OpenSSLEngine object (or null if not available)
*/
@CalledByNative
private static Object getOpenSSLEngineForPrivateKey(PrivateKey privateKey) {
// Find the system OpenSSLEngine class.
Class<?> engineClass;
try {
engineClass = Class.forName("org.apache.harmony.xnet.provider.jsse.OpenSSLEngine");
} catch (Exception e) {
// This may happen if the target device has a completely different
// implementation of the java.security APIs, compared to vanilla
// Android. Highly unlikely, but still possible.
Log.e(TAG, "Cannot find system OpenSSLEngine class: " + e);
return null;
}
Object opensslKey = getOpenSSLKeyForPrivateKey(privateKey);
if (opensslKey == null) return null;
try {
// Use reflection to invoke the 'getEngine' method on the
// result of the getOpenSSLKey().
Method getEngine;
try {
getEngine = opensslKey.getClass().getDeclaredMethod("getEngine");
} catch (Exception e) {
// Bail here too, something really not working as expected.
Log.e(TAG, "No getEngine() method on OpenSSLKey member:" + e);
return null;
}
getEngine.setAccessible(true);
Object engine = null;
try {
engine = getEngine.invoke(opensslKey);
} finally {
getEngine.setAccessible(false);
}
if (engine == null) {
// The PrivateKey is probably rotten for some reason.
Log.e(TAG, "getEngine() returned null");
}
// Sanity-check the returned engine.
if (!engineClass.isInstance(engine)) {
Log.e(
TAG,
"Engine is not an OpenSSLEngine instance, its class name is:"
+ engine.getClass().getCanonicalName());
return null;
}
return engine;
} catch (Exception e) {
Log.e(TAG, "Exception while trying to retrieve OpenSSLEngine object: " + e);
return null;
}
}
@SuppressWarnings("unused")
@CalledByNative
private void destroySurfaceTextureSurface(int surfaceTextureId, int clientId) {
if (mCallback == null) {
Log.e(TAG, "No callback interface has been provided.");
return;
}
try {
mCallback.unregisterSurfaceTextureSurface(surfaceTextureId, clientId);
} catch (RemoteException e) {
Log.e(TAG, "Unable to call unregisterSurfaceTextureSurface: %s", e);
}
}
@SuppressWarnings("unused")
@CalledByNative
private Surface getSurfaceTextureSurface(int surfaceTextureId) {
if (mCallback == null) {
Log.e(TAG, "No callback interface has been provided.");
return null;
}
try {
return mCallback.getSurfaceTextureSurface(surfaceTextureId).getSurface();
} catch (RemoteException e) {
Log.e(TAG, "Unable to call getSurfaceTextureSurface: %s", e);
return null;
}
}
// SET_VOLUME messages have a |level| and |muted| properties. One of them is
// |null| and the other one isn't. |muted| is expected to be a boolean while
// |level| is a float from 0.0 to 1.0.
// Example:
// {
// "volume" {
// "level": 0.9,
// "muted": null
// }
// }
@Override
public HandleVolumeMessageResult handleVolumeMessage(
JSONObject volume, final String clientId, final int sequenceNumber) throws JSONException {
if (volume == null) return new HandleVolumeMessageResult(false, false);
if (isApiClientInvalid()) return new HandleVolumeMessageResult(false, false);
boolean waitForVolumeChange = false;
try {
if (!volume.isNull("muted")) {
boolean newMuted = volume.getBoolean("muted");
if (Cast.CastApi.isMute(mApiClient) != newMuted) {
Cast.CastApi.setMute(mApiClient, newMuted);
waitForVolumeChange = true;
}
}
if (!volume.isNull("level")) {
double newLevel = volume.getDouble("level");
double currentLevel = Cast.CastApi.getVolume(mApiClient);
if (!Double.isNaN(currentLevel)
&& Math.abs(currentLevel - newLevel) > MIN_VOLUME_LEVEL_DELTA) {
Cast.CastApi.setVolume(mApiClient, newLevel);
waitForVolumeChange = true;
}
}
} catch (IOException e) {
Log.e(TAG, "Failed to send volume command: " + e);
return new HandleVolumeMessageResult(false, false);
}
return new HandleVolumeMessageResult(true, waitForVolumeChange);
}
private void ensureLocationManagerCreated() {
if (mLocationManager != null) return;
mLocationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
if (mLocationManager == null) {
Log.e(TAG, "Could not get location manager.");
}
}
@SuppressWarnings("unused")
@CalledByNative
private void createSurfaceTextureSurface(
int surfaceTextureId, int clientId, SurfaceTexture surfaceTexture) {
if (mCallback == null) {
Log.e(TAG, "No callback interface has been provided.");
return;
}
Surface surface = new Surface(surfaceTexture);
try {
mCallback.registerSurfaceTextureSurface(surfaceTextureId, clientId, surface);
} catch (RemoteException e) {
Log.e(TAG, "Unable to call registerSurfaceTextureSurface: %s", e);
}
surface.release();
}
private static void deleteFileForOverwrite(DownloadInfo info) {
assert !ThreadUtils.runningOnUiThread();
File dir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
if (!dir.isDirectory()) return;
final File file = new File(dir, info.getFileName());
if (!file.delete()) {
Log.e(TAG, "Failed to delete a file: " + info.getFileName());
}
}
/**
* Check the external storage and notify user on error.
*
* @param fullDirPath The dir path to download a file. Normally this is external storage.
* @param externalStorageStatus The status of the external storage.
* @return Whether external storage is ok for downloading.
*/
private boolean checkExternalStorageAndNotify(
String filename, String fullDirPath, String externalStorageStatus) {
if (fullDirPath == null) {
Log.e(TAG, "Download failed: no SD card");
alertDownloadFailure(filename);
return false;
}
if (!externalStorageStatus.equals(Environment.MEDIA_MOUNTED)) {
// Check to see if the SDCard is busy, same as the music app
if (externalStorageStatus.equals(Environment.MEDIA_SHARED)) {
Log.e(TAG, "Download failed: SD card unavailable");
} else {
Log.e(TAG, "Download failed: no SD card");
}
alertDownloadFailure(filename);
return false;
}
return true;
}
private void unregisterNamespace(String namespace) {
assert mNamespaces.contains(namespace);
if (isApiClientInvalid()) return;
try {
Cast.CastApi.removeMessageReceivedCallbacks(mApiClient, namespace);
mNamespaces.remove(namespace);
} catch (IOException e) {
Log.e(TAG, "Failed to remove the namespace listener for %s", namespace, e);
}
}
@CalledByNative
private static SurfaceWrapper getSurfaceTextureSurface(int surfaceTextureId, int clientId) {
Pair<Integer, Integer> key = new Pair<Integer, Integer>(surfaceTextureId, clientId);
Surface surface = sSurfaceTextureSurfaceMap.get(key);
if (surface == null) {
Log.e(TAG, "Invalid Id for surface texture.");
return null;
}
assert surface.isValid();
return new SurfaceWrapper(surface);
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Intent intent = getIntent();
WebappInfo webappInfo = WebappInfo.create(intent);
String webappId = webappInfo.id();
String webappUrl = webappInfo.uri().toString();
int webappSource = webappInfo.source();
if (webappId != null && webappUrl != null) {
String webappMacString = IntentUtils.safeGetStringExtra(intent, ShortcutHelper.EXTRA_MAC);
byte[] webappMac =
webappMacString == null ? null : Base64.decode(webappMacString, Base64.DEFAULT);
Intent launchIntent = null;
if (webappMac != null && WebappAuthenticator.isUrlValid(this, webappUrl, webappMac)) {
LaunchMetrics.recordHomeScreenLaunchIntoStandaloneActivity(webappUrl, webappSource);
String activityName = WebappActivity.class.getName();
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
// Specifically assign the app to a particular WebappActivity instance.
int activityIndex = ActivityAssigner.instance(this).assign(webappId);
activityName += String.valueOf(activityIndex);
}
// Create an intent to launch the Webapp in an unmapped WebappActivity.
launchIntent = new Intent();
launchIntent.setClassName(this, activityName);
webappInfo.setWebappIntentExtras(launchIntent);
// On L+, firing intents with the exact same data should relaunch a particular
// Activity.
launchIntent.setAction(Intent.ACTION_VIEW);
launchIntent.setData(Uri.parse(WebappActivity.WEBAPP_SCHEME + "://" + webappId));
} else {
Log.e(TAG, "Shortcut (" + webappUrl + ") opened in Chrome.");
// The shortcut data doesn't match the current encoding. Change the intent action
// launch the URL with a VIEW Intent in the regular browser.
launchIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(webappUrl));
launchIntent.setClassName(getPackageName(), ChromeLauncherActivity.class.getName());
launchIntent.putExtra(ShortcutHelper.REUSE_URL_MATCHING_TAB_ELSE_NEW_TAB, true);
launchIntent.putExtra(ShortcutHelper.EXTRA_SOURCE, webappSource);
}
launchIntent.setFlags(
Intent.FLAG_ACTIVITY_NEW_TASK | ApiCompatibilityUtils.getActivityNewDocumentFlag());
startActivity(launchIntent);
}
ApiCompatibilityUtils.finishAndRemoveTask(this);
}
@CalledByNative
private static void launchExternalProtocol(String url) {
Context context = ApplicationStatus.getApplicationContext();
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.addCategory(Intent.CATEGORY_BROWSABLE);
try {
context.startActivity(intent);
} catch (ActivityNotFoundException e) {
Log.e(TAG, "cannot find activity to launch " + url, e);
}
}
/**
* Sign a given message with a given PrivateKey object. This method shall only be used to
* implement signing in the context of SSL client certificate support.
*
* <p>The message will actually be a hash, computed by OpenSSL itself, depending on the type of
* the key. The result should match exactly what the vanilla implementations of the following
* OpenSSL function calls do:
*
* <p>- For a RSA private key, this should be equivalent to calling RSA_private_encrypt(...,
* RSA_PKCS1_PADDING), i.e. it must generate a raw RSA signature. The message must be either a
* combined, 36-byte MD5+SHA1 message digest or a DigestInfo value wrapping a message digest.
*
* <p>- For a ECDSA private keys, this should be equivalent to calling ECDSA_sign(0,...). The
* message must be a hash and the function shall compute a direct ECDSA signature for it.
*
* @param privateKey The PrivateKey handle.
* @param message The message to sign.
* @return signature as a byte buffer.
* <p>Important: Due to a platform bug, this function will always fail on Android < 4.2 for
* RSA PrivateKey objects. See the getOpenSSLHandleForPrivateKey() below for work-around.
*/
@CalledByNative
private static byte[] rawSignDigestWithPrivateKey(PrivateKey privateKey, byte[] message) {
// Get the Signature for this key.
Signature signature = null;
// Hint: Algorithm names come from:
// http://docs.oracle.com/javase/6/docs/technotes/guides/security/StandardNames.html
try {
String keyAlgorithm = privateKey.getAlgorithm();
if ("RSA".equalsIgnoreCase(keyAlgorithm)) {
// IMPORTANT: Due to a platform bug, this will throw NoSuchAlgorithmException
// on Android 4.1.x. Fixed in 4.2 and higher.
// See https://android-review.googlesource.com/#/c/40352/
signature = Signature.getInstance("NONEwithRSA");
} else if ("EC".equalsIgnoreCase(keyAlgorithm)) {
signature = Signature.getInstance("NONEwithECDSA");
}
} catch (NoSuchAlgorithmException e) {
// Intentionally do nothing.
}
if (signature == null) {
Log.e(TAG, "Unsupported private key algorithm: " + privateKey.getAlgorithm());
return null;
}
// Sign the message.
try {
signature.initSign(privateKey);
signature.update(message);
return signature.sign();
} catch (Exception e) {
Log.e(
TAG,
"Exception while signing message with "
+ privateKey.getAlgorithm()
+ " private key: "
+ e);
return null;
}
}
/**
* Return the system EVP_PKEY handle corresponding to a given PrivateKey object.
*
* <p>This shall only be used when the "NONEwithRSA" signature is not available, as described in
* rawSignDigestWithPrivateKey(). I.e. never use this on Android 4.2 or higher.
*
* <p>This can only work in Android 4.0.4 and higher, for older versions of the platform (e.g.
* 4.0.3), there is no system OpenSSL EVP_PKEY, but the private key contents can be retrieved
* directly with the getEncoded() method.
*
* <p>This assumes that the target device uses a vanilla AOSP implementation of its java.security
* classes, which is also based on OpenSSL (fortunately, no OEM has apperently changed to a
* different implementation, according to the Android team).
*
* <p>Note that the object returned was created with the platform version of OpenSSL, and _not_
* the one that comes with Chromium. It may not be used with the Chromium version of OpenSSL
* (BoringSSL). See AndroidEVP_PKEY in net/android/legacy_openssl.h.
*
* <p>To better understand what's going on below, please refer to the following source files in
* the Android 4.0.4 and 4.1 source trees:
* libcore/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
* libcore/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
*
* @param privateKey The PrivateKey handle.
* @return The EVP_PKEY handle, as a 32-bit integer (0 if not available)
*/
@CalledByNative
private static long getOpenSSLHandleForPrivateKey(PrivateKey privateKey) {
Object opensslKey = getOpenSSLKeyForPrivateKey(privateKey);
if (opensslKey == null) return 0;
try {
// Use reflection to invoke the 'getPkeyContext' method on the
// result of the getOpenSSLKey(). This is an 32-bit integer
// which is the address of an EVP_PKEY object. Note that this
// method these days returns a 64-bit long, but since this code
// path is used for older Android versions, it may still return
// a 32-bit int here. To be on the safe side, we cast the return
// value via Number rather than directly to Integer or Long.
Method getPkeyContext;
try {
getPkeyContext = opensslKey.getClass().getDeclaredMethod("getPkeyContext");
} catch (Exception e) {
// Bail here too, something really not working as expected.
Log.e(TAG, "No getPkeyContext() method on OpenSSLKey member:" + e);
return 0;
}
getPkeyContext.setAccessible(true);
long evp_pkey = 0;
try {
evp_pkey = ((Number) getPkeyContext.invoke(opensslKey)).longValue();
} finally {
getPkeyContext.setAccessible(false);
}
if (evp_pkey == 0) {
// The PrivateKey is probably rotten for some reason.
Log.e(TAG, "getPkeyContext() returned null");
}
return evp_pkey;
} catch (Exception e) {
Log.e(TAG, "Exception while trying to retrieve system EVP_PKEY handle: " + e);
return 0;
}
}
private static Object getOpenSSLKeyForPrivateKey(PrivateKey privateKey) {
// Sanity checks
if (privateKey == null) {
Log.e(TAG, "privateKey == null");
return null;
}
if (!(privateKey instanceof RSAPrivateKey)) {
Log.e(TAG, "does not implement RSAPrivateKey");
return null;
}
// First, check that this is a proper instance of OpenSSLRSAPrivateKey
// or one of its sub-classes.
Class<?> superClass;
try {
superClass = Class.forName("org.apache.harmony.xnet.provider.jsse.OpenSSLRSAPrivateKey");
} catch (Exception e) {
// This may happen if the target device has a completely different
// implementation of the java.security APIs, compared to vanilla
// Android. Highly unlikely, but still possible.
Log.e(TAG, "Cannot find system OpenSSLRSAPrivateKey class: " + e);
return null;
}
if (!superClass.isInstance(privateKey)) {
// This may happen if the PrivateKey was not created by the "AndroidOpenSSL"
// provider, which should be the default. That could happen if an OEM decided
// to implement a different default provider. Also highly unlikely.
Log.e(
TAG,
"Private key is not an OpenSSLRSAPrivateKey instance, its class name is:"
+ privateKey.getClass().getCanonicalName());
return null;
}
try {
// Use reflection to invoke the 'getOpenSSLKey()' method on the
// private key. This returns another Java object that wraps a native
// EVP_PKEY and OpenSSLEngine. Note that the method is final in Android
// 4.1, so calling the superclass implementation is ok.
Method getKey = superClass.getDeclaredMethod("getOpenSSLKey");
getKey.setAccessible(true);
Object opensslKey = null;
try {
opensslKey = getKey.invoke(privateKey);
} finally {
getKey.setAccessible(false);
}
if (opensslKey == null) {
// Bail when detecting OEM "enhancement".
Log.e(TAG, "getOpenSSLKey() returned null");
return null;
}
return opensslKey;
} catch (Exception e) {
Log.e(TAG, "Exception while trying to retrieve system EVP_PKEY handle: " + e);
return null;
}
}
@CalledByNative
public boolean startPrompt() {
Log.d(TAG, "startPrompt");
Activity activity = ApplicationStatus.getLastTrackedFocusedActivity();
if (activity == null) {
Log.e(TAG, "activity is null");
return false;
}
FragmentManager fragmentManager = activity.getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
fragmentTransaction.add(this, "screencapture");
try {
fragmentTransaction.commit();
} catch (RuntimeException e) {
Log.e(TAG, "ScreenCaptureExcaption " + e);
return false;
}
synchronized (mCaptureStateLock) {
while (mCaptureState != CaptureState.ATTACHED) {
try {
mCaptureStateLock.wait();
} catch (InterruptedException ex) {
Log.e(TAG, "ScreenCaptureException: " + ex);
}
}
}
try {
startActivityForResult(
mMediaProjectionManager.createScreenCaptureIntent(), REQUEST_MEDIA_PROJECTION);
} catch (android.content.ActivityNotFoundException e) {
Log.e(TAG, "ScreenCaptureException " + e);
return false;
}
return true;
}
/**
* Extracts the mojo applications from the apk assets and returns the directory where they are.
*/
@CalledByNative
private static String extractMojoApplications(Context context) throws IOException {
File cachedAppsDir = FileHelper.getCachedAppsDir(context);
try {
FileHelper.prepareDirectoryForAssets(context, cachedAppsDir);
for (String assetPath : FileHelper.getAssetsList(context)) {
FileHelper.extractFromAssets(
context, assetPath, cachedAppsDir, FileHelper.FileType.PERMANENT);
}
} catch (Exception e) {
Log.e(TAG, "ShellTestBase initialization failed.", e);
throw new RuntimeException(e);
}
return cachedAppsDir.getAbsolutePath();
}
/**
* Receive a broadcast intent.
*
* @param context The Context in which the receiver is running.
* @param intent The intent received.
*/
@Override
public void onReceive(Context context, Intent intent) {
int pid = intent.getIntExtra(TestStatusReporter.EXTRA_PID, 0);
String testClass = intent.getStringExtra(TestStatusReporter.EXTRA_TEST_CLASS);
String testMethod = intent.getStringExtra(TestStatusReporter.EXTRA_TEST_METHOD);
String stackTrace = intent.getStringExtra(TestStatusReporter.EXTRA_STACK_TRACE);
switch (intent.getAction()) {
case TestStatusReporter.ACTION_TEST_STARTED:
for (StartCallback c : mStartCallbacks) {
c.testStarted(testClass, testMethod);
}
break;
case TestStatusReporter.ACTION_TEST_PASSED:
for (PassCallback c : mPassCallbacks) {
c.testPassed(testClass, testMethod);
}
break;
case TestStatusReporter.ACTION_TEST_FAILED:
for (FailCallback c : mFailCallbacks) {
c.testFailed(testClass, testMethod, stackTrace);
}
break;
case TestStatusReporter.ACTION_HEARTBEAT:
for (HeartbeatCallback c : mHeartbeatCallbacks) {
c.heartbeat();
}
break;
case TestStatusReporter.ACTION_TEST_RUN_STARTED:
for (TestRunCallback c : mTestRunCallbacks) {
c.testRunStarted(pid);
}
break;
case TestStatusReporter.ACTION_TEST_RUN_FINISHED:
for (TestRunCallback c : mTestRunCallbacks) {
c.testRunFinished(pid);
}
break;
case TestStatusReporter.ACTION_UNCAUGHT_EXCEPTION:
for (TestRunCallback c : mTestRunCallbacks) {
c.uncaughtException(pid, stackTrace);
}
break;
default:
Log.e(TAG, "Unrecognized intent received: %s", intent.toString());
break;
}
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
AwShellResourceProvider.registerResources(this);
ContentApplication.initCommandLine(this);
waitForDebuggerIfNeeded();
AwBrowserProcess.loadLibrary(this);
if (CommandLine.getInstance().hasSwitch(AwShellSwitches.ENABLE_ATRACE)) {
Log.e(TAG, "Enabling Android trace.");
TraceEvent.setATraceEnabled(true);
}
setContentView(R.layout.testshell_activity);
mAwTestContainerView = createAwTestContainerView();
mWebContents = mAwTestContainerView.getContentViewCore().getWebContents();
mNavigationController = mWebContents.getNavigationController();
LinearLayout contentContainer = (LinearLayout) findViewById(R.id.content_container);
mAwTestContainerView.setLayoutParams(
new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT, 1f));
contentContainer.addView(mAwTestContainerView);
mAwTestContainerView.requestFocus();
initializeUrlField();
initializeNavigationButtons();
String startupUrl = getUrlFromIntent(getIntent());
if (TextUtils.isEmpty(startupUrl)) {
startupUrl = INITIAL_URL;
}
mAwTestContainerView.getAwContents().loadUrl(new LoadUrlParams(startupUrl));
AwContents.setShouldDownloadFavicons();
mUrlTextView.setText(startupUrl);
if (CommandLine.getInstance().hasSwitch(ENABLE_DATA_REDUCTION_PROXY)) {
String key = CommandLine.getInstance().getSwitchValue(DATA_REDUCTION_PROXY_KEY);
if (key != null && !key.isEmpty()) {
AwContentsStatics.setDataReductionProxyKey(key);
AwContentsStatics.setDataReductionProxyEnabled(true);
}
}
}
/**
* Creates a secure Cipher for encrypting data. This function blocks until data needed to generate
* a Cipher has been created by the background thread.
*
* @param opmode One of Cipher.{ENCRYPT,DECRYPT}_MODE.
* @return A Cipher, or null if it is not possible to instantiate one.
*/
public Cipher getCipher(int opmode) {
CipherData data = getCipherData(true);
if (data != null) {
try {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(opmode, data.key, new IvParameterSpec(data.iv));
return cipher;
} catch (GeneralSecurityException e) {
// Can't do anything here.
}
}
Log.e(TAG, "Error in creating cipher instance.");
return null;
}
@Override
public void updateSessionStatus() {
if (isApiClientInvalid()) return;
try {
mApplicationStatus = Cast.CastApi.getApplicationStatus(mApiClient);
mApplicationMetadata = Cast.CastApi.getApplicationMetadata(mApiClient);
updateNamespaces();
mMessageHandler.broadcastClientMessage(
"update_session", mMessageHandler.buildSessionMessage());
} catch (IllegalStateException e) {
Log.e(TAG, "Can't get application status", e);
}
}
@CalledByNative
private static FileDescriptorInfo makeFdInfo(
int id, int fd, boolean autoClose, long offset, long size) {
ParcelFileDescriptor pFd;
if (autoClose) {
// Adopt the FD, it will be closed when we close the ParcelFileDescriptor.
pFd = ParcelFileDescriptor.adoptFd(fd);
} else {
try {
pFd = ParcelFileDescriptor.fromFd(fd);
} catch (IOException e) {
Log.e(TAG, "Invalid FD provided for process connection, aborting connection.", e);
return null;
}
}
return new FileDescriptorInfo(id, pFd, offset, size);
}
private void addNamespace(String namespace) {
assert !mNamespaces.contains(namespace);
if (isApiClientInvalid()) return;
// If application metadata is null, register the callback anyway.
if (mApplicationMetadata != null && !mApplicationMetadata.isNamespaceSupported(namespace)) {
return;
}
try {
Cast.CastApi.setMessageReceivedCallbacks(mApiClient, namespace, mMessageChannel);
mNamespaces.add(namespace);
} catch (IOException e) {
Log.e(TAG, "Failed to register namespace listener for %s", namespace, e);
}
}
@Override
protected List<SnippetListItem> doInBackground(Void... params) {
FileInputStream fis = null;
try {
fis =
new FileInputStream(
new File(
Environment.getExternalStorageDirectory().getPath()
+ "/chrome/reading_list.json"));
List<SnippetListItem> listSnippetsGroups = readJsonStream(fis);
return listSnippetsGroups;
} catch (IOException ex) {
Log.e(TAG, "Exception reading file: %s ", ex);
} finally {
StreamUtil.closeQuietly(fis);
}
return null;
}