private void runInstall() {
    int installFlags = 0;

    String opt;
    while ((opt = nextOption()) != null) {
      if (opt.equals("-l")) {
        installFlags |= PackageManager.FORWARD_LOCK_PACKAGE;
      } else if (opt.equals("-r")) {
        installFlags |= PackageManager.REPLACE_EXISTING_PACKAGE;
      } else {
        System.err.println("Error: Unknown option: " + opt);
        showUsage();
        return;
      }
    }

    String apkFilePath = nextArg();
    System.err.println("\tpkg: " + apkFilePath);
    if (apkFilePath == null) {
      System.err.println("Error: no package specified");
      showUsage();
      return;
    }

    PackageInstallObserver obs = new PackageInstallObserver();
    try {
      mPm.installPackage(Uri.fromFile(new File(apkFilePath)), obs, installFlags);

      synchronized (obs) {
        while (!obs.finished) {
          try {
            obs.wait();
          } catch (InterruptedException e) {
          }
        }
        if (obs.result == PackageManager.INSTALL_SUCCEEDED) {
          System.out.println("Success");
        } else {
          System.err.println("Failure [" + installFailureToString(obs.result) + "]");
        }
      }
    } catch (RemoteException e) {
      System.err.println(e.toString());
      System.err.println(PM_NOT_RUNNING_ERR);
    }
  }
  private void preInstall() {
    String path = nextArg();
    int i;

    System.err.println("\t preInstall path: " + path);
    if (path == null) {
      System.err.println("Error: no package specified");
      showUsage();
      return;
    }

    File[] files = new File(path).listFiles();

    for (File apkFilePath : files) {
      System.err.println("\tpkg: " + apkFilePath);
      PackageInstallObserver obs = new PackageInstallObserver();
      try {
        mPm.installPackage(Uri.fromFile(apkFilePath), obs, 0, null);
        System.err.println("\t pkg----1------: ");
        synchronized (obs) {
          while (!obs.finished) {
            try {
              System.err.println("\t pkg----2------: ");
              obs.wait();
              System.err.println("\t pkg----3------: ");
            } catch (InterruptedException e) {
              System.err.println("\t pkg----4------: ");
            }
          }
          if (obs.result == PackageManager.INSTALL_SUCCEEDED) {
            System.out.println("Success");
          } else {
            System.err.println("Failure [" + installFailureToString(obs.result) + "]");
          }
        }
      } catch (RemoteException e) {
        System.err.println(e.toString());
        System.err.println(PM_NOT_RUNNING_ERR);
      }
    }
    System.err.println("\t preInstall path: " + path + " ok");
  }
  public static int installSilence(Context context, String filePath, boolean isUpdate) {
    File file = new File(filePath);

    if (!file.isFile() || !file.exists()) {
      return 0;
    }
    Uri packageURI = Uri.fromFile(file);
    int installFlags = 0;
    PackageManager pm = context.getPackageManager();
    PackageInfo info = pm.getPackageArchiveInfo(filePath, PackageManager.GET_ACTIVITIES);
    if (info != null) {
      try {
        PackageInfo pi =
            pm.getPackageInfo(info.packageName, PackageManager.GET_UNINSTALLED_PACKAGES);
        if (pi != null) {
          if (isUpdate) {
            installFlags |= ACA.PackageManager.INSTALL_REPLACE_EXISTING;
          } else {
            return ACA.PackageManager.INSTALL_SUCCEEDED;
          }
        }
      } catch (NameNotFoundException e) {
        // the package did't installed, go ahead
        e.printStackTrace();
      }
      PackageInstallObserver obs = new PackageInstallObserver();
      ACA.PackageManager.installPackage(pm, packageURI, obs, installFlags, info.packageName);
      synchronized (obs) {
        while (!obs.finished) {
          try {
            obs.wait();
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        ;
        return obs.result;
      }
    }
    return 0;
  }
  private void runInstall() {
    int installFlags = PackageManager.INSTALL_ALL_USERS;
    String installerPackageName = null;

    String opt;

    String algo = null;
    byte[] iv = null;
    byte[] key = null;

    String macAlgo = null;
    byte[] macKey = null;
    byte[] tag = null;
    String originatingUriString = null;
    String referrer = null;

    while ((opt = nextOption()) != null) {
      if (opt.equals("-l")) {
        installFlags |= PackageManager.INSTALL_FORWARD_LOCK;
      } else if (opt.equals("-r")) {
        installFlags |= PackageManager.INSTALL_REPLACE_EXISTING;
      } else if (opt.equals("-i")) {
        installerPackageName = nextOptionData();
        if (installerPackageName == null) {
          System.err.println("Error: no value specified for -i");
          return;
        }
      } else if (opt.equals("-t")) {
        installFlags |= PackageManager.INSTALL_ALLOW_TEST;
      } else if (opt.equals("-s")) {
        // Override if -s option is specified.
        installFlags |= PackageManager.INSTALL_EXTERNAL;
      } else if (opt.equals("-f")) {
        // Override if -s option is specified.
        installFlags |= PackageManager.INSTALL_INTERNAL;
      } else if (opt.equals("-d")) {
        installFlags |= PackageManager.INSTALL_ALLOW_DOWNGRADE;
      } else if (opt.equals("--algo")) {
        algo = nextOptionData();
        if (algo == null) {
          System.err.println("Error: must supply argument for --algo");
          return;
        }
      } else if (opt.equals("--iv")) {
        iv = hexToBytes(nextOptionData());
        if (iv == null) {
          System.err.println("Error: must supply argument for --iv");
          return;
        }
      } else if (opt.equals("--key")) {
        key = hexToBytes(nextOptionData());
        if (key == null) {
          System.err.println("Error: must supply argument for --key");
          return;
        }
      } else if (opt.equals("--macalgo")) {
        macAlgo = nextOptionData();
        if (macAlgo == null) {
          System.err.println("Error: must supply argument for --macalgo");
          return;
        }
      } else if (opt.equals("--mackey")) {
        macKey = hexToBytes(nextOptionData());
        if (macKey == null) {
          System.err.println("Error: must supply argument for --mackey");
          return;
        }
      } else if (opt.equals("--tag")) {
        tag = hexToBytes(nextOptionData());
        if (tag == null) {
          System.err.println("Error: must supply argument for --tag");
          return;
        }
      } else if (opt.equals("--originating-uri")) {
        originatingUriString = nextOptionData();
        if (originatingUriString == null) {
          System.err.println("Error: must supply argument for --originating-uri");
          return;
        }
      } else if (opt.equals("--referrer")) {
        referrer = nextOptionData();
        if (referrer == null) {
          System.err.println("Error: must supply argument for --referrer");
          return;
        }
      } else {
        System.err.println("Error: Unknown option: " + opt);
        return;
      }
    }

    final ContainerEncryptionParams encryptionParams;
    if (algo != null
        || iv != null
        || key != null
        || macAlgo != null
        || macKey != null
        || tag != null) {
      if (algo == null || iv == null || key == null) {
        System.err.println("Error: all of --algo, --iv, and --key must be specified");
        return;
      }

      if (macAlgo != null || macKey != null || tag != null) {
        if (macAlgo == null || macKey == null || tag == null) {
          System.err.println("Error: all of --macalgo, --mackey, and --tag must " + "be specified");
          return;
        }
      }

      try {
        final SecretKey encKey = new SecretKeySpec(key, "RAW");

        final SecretKey macSecretKey;
        if (macKey == null || macKey.length == 0) {
          macSecretKey = null;
        } else {
          macSecretKey = new SecretKeySpec(macKey, "RAW");
        }

        encryptionParams =
            new ContainerEncryptionParams(
                algo,
                new IvParameterSpec(iv),
                encKey,
                macAlgo,
                null,
                macSecretKey,
                tag,
                -1,
                -1,
                -1);
      } catch (InvalidAlgorithmParameterException e) {
        e.printStackTrace();
        return;
      }
    } else {
      encryptionParams = null;
    }

    final Uri apkURI;
    final Uri verificationURI;
    final Uri originatingURI;
    final Uri referrerURI;

    if (originatingUriString != null) {
      originatingURI = Uri.parse(originatingUriString);
    } else {
      originatingURI = null;
    }

    if (referrer != null) {
      referrerURI = Uri.parse(referrer);
    } else {
      referrerURI = null;
    }

    // Populate apkURI, must be present
    final String apkFilePath = nextArg();
    System.err.println("\tpkg: " + apkFilePath);
    if (apkFilePath != null) {
      apkURI = Uri.fromFile(new File(apkFilePath));
    } else {
      System.err.println("Error: no package specified");
      return;
    }

    // Populate verificationURI, optionally present
    final String verificationFilePath = nextArg();
    if (verificationFilePath != null) {
      System.err.println("\tver: " + verificationFilePath);
      verificationURI = Uri.fromFile(new File(verificationFilePath));
    } else {
      verificationURI = null;
    }

    PackageInstallObserver obs = new PackageInstallObserver();
    try {
      VerificationParams verificationParams =
          new VerificationParams(
              verificationURI, originatingURI, referrerURI, VerificationParams.NO_UID, null);

      mPm.installPackageWithVerificationAndEncryption(
          apkURI, obs, installFlags, installerPackageName, verificationParams, encryptionParams);

      synchronized (obs) {
        while (!obs.finished) {
          try {
            obs.wait();
          } catch (InterruptedException e) {
          }
        }
        if (obs.result == PackageManager.INSTALL_SUCCEEDED) {
          System.out.println("Success");
        } else {
          System.err.println("Failure [" + installFailureToString(obs.result) + "]");
        }
      }
    } catch (RemoteException e) {
      System.err.println(e.toString());
      System.err.println(PM_NOT_RUNNING_ERR);
    }
  }