Ich versuche, apk stillschweigend im System zu installieren. Meine App befindet sich in / system / app und hat erfolgreich die Berechtigung "android.permission.INSTALL_PACKAGES" erhalten.

Ich kann jedoch nirgendwo finden, wie ich diese Berechtigung verwenden kann. Ich habe versucht, Dateien nach / data / app zu kopieren und hatte keinen Erfolg. Ich habe auch versucht, diesen Code zu verwenden

    Intent intent = new Intent(Intent.ACTION_VIEW);
    intent.setDataAndType(
            Uri.parse("file:///sdcard/app.apk"),
            "application/vnd.android.package-archive");
    startActivity(intent);

Dieser Code öffnet jedoch den Standardinstallationsdialog. Wie kann ich App ohne Root mit gewährtem Hintergrund still installieren android.permission.INSTALL_PACKAGES?

PS Ich schreibe eine App, die beim ersten Start viele Apks aus dem Ordner auf dem System installiert (Setup-Assistent ersetzen). Ich brauche es, um die Firmware leichter zu machen.

Wenn Sie denken, dass ich einen Virus schreibe: Alle Programme sind in / data / app installiert. Berechtigung Install_packages kann nur Programmen auf Systemebene erteilt werden, die sich in / system / app befinden oder mit dem Systemschlüssel signiert sind. Viren können also nicht dorthin gelangen.

Wie bereits erwähnt, können Apps unter http://www.mail-archive.com/[email protected]/msg06281.html unbeaufsichtigt installiert werden, wenn sie über die Berechtigung install_packages verfügen. Darüber hinaus benötigen Sie keine Install_packages-Berechtigung, um Pakete nicht unbeaufsichtigt zu installieren. Plus http://www.androidzoom.com/android_applications/tools/silent-installer_wgqi.html

Ihre erste Wette besteht darin, sich den nativen PackageInstaller von Android anzusehen . Ich würde empfehlen, diese App nach Ihren Wünschen zu ändern oder einfach die erforderlichen Funktionen zu extrahieren.

Insbesondere, wenn Sie sich PackageInstallerActivity und seine Methode ansehen onClickListener:

 public void onClick(View v) {
    if(v == mOk) {
        // Start subactivity to actually install the application
        Intent newIntent = new Intent();
        ...
        newIntent.setClass(this, InstallAppProgress.class);
        ...
        startActivity(newIntent);
        finish();
    } else if(v == mCancel) {
        // Cancel and finish
        finish();
    }
}

Dann werden Sie feststellen, dass sich das eigentliche Installationsprogramm in der InstallAppProgress- Klasse befindet. Wenn Sie diese Klasse untersuchen, werden Sie feststellen, dass dies initViewdie Kernfunktion des Installationsprogramms ist, und als letztes wird sie aufgerufenPackageManager ‚s installPackageFunktion:

public void initView() {
...
pm.installPackage(mPackageURI, observer, installFlags, installerPackageName);
}

Der nächste Schritt besteht darin, PackageManager zu überprüfen , eine abstrakte Klasse. Dort finden Sie installPackage(...)Funktion. Die schlechte Nachricht ist, dass es mit @hide markiert ist. Dies bedeutet, dass es nicht direkt verfügbar ist (Sie können mit dem Aufruf dieser Methode nicht kompilieren).

 /**
  * @hide
  * ....
  */
  public abstract void installPackage(Uri packageURI,
             IPackageInstallObserver observer, 
             int flags,String installerPackageName); 

Sie können jedoch über Reflexion auf diese Methoden zugreifen.

Wenn Sie in , wie interessiert PackageManager‚sinstallPackage Funktion implementiert wird, schauen Sie sich PackageManagerService an .

Zusammenfassung

Sie müssen das Paketmanager-Objekt über Context's abrufen getPackageManager(). Dann rufen Sie die installPackageFunktion über Reflexion auf.

Ich habe überprüft, wie ADB Apps installiert.
- Es kopiert die APK nach / data / local / tmp.
- Es wird 'shell: pm install /data/local/tmp/app.apk' ausgeführt.

Ich habe versucht, dieses Verhalten zu replizieren, indem ich Folgendes getan habe: (auf einem PC mit USB-Kabel)
adb push app.apk /sdcard/app.apk
adb shell
$ pm install /sdcard/app.apk
Dies funktioniert. Die App ist installiert.

Ich habe eine Anwendung (mit dem Namen AppInstall) erstellt, die die andere App installieren soll.
(normal installiertes, nicht gerootetes Gerät)
Es tut:
Runtime.getRuntime().exec("pm install /sdcard/app.apk").waitFor();
Aber dies gibt den Fehler:
java.lang.SecurityException: Neither user 10019 nor current process has android.permission.INSTALL_PACKAGES.
Es scheint, als würde der Fehler von pm und nicht von AppInstall ausgelöst.
Weil die SecurityException nicht von AppInstall abgefangen wird und die App nicht abstürzt.

Ich habe dasselbe auf einem gerooteten Gerät (gleiche App und AppInstall) versucht und es hat wie ein Zauber funktioniert.
(Auch normalerweise installiert, nicht in / system oder so)
AppInstall hat nicht einmal nach der Root-Erlaubnis gefragt.
Aber das liegt daran, dass sich die Shell immer #statt $auf diesem Gerät befindet.

Übrigens, Sie benötigen root, um eine App in / system zu installieren, richtig?
Ich habe versucht, adb remount auf dem nicht gerooteten Gerät durchzuführen und habe Folgendes erhalten:
remount failed: Operation not permitted.
Deshalb konnte ich das / system-Ding auf dem nicht nicht ausprobieren.

Fazit: Sie sollten ein gerootetes Gerät verwenden
Hoffe das hilft :)

Ich habe kürzlich die Installation ohne Zustimmung des Benutzers implementiert - es war eine Kiosk-Anwendung für API Level 21+, bei der ich die volle Kontrolle über die Umgebung hatte.

Die Grundvoraussetzungen sind

• API Level 21+
• Root-Zugriff , um den Updater als systemprivilegierte App zu installieren.

Die folgende Methode liest und installiert APK aus InputStream:

public static boolean installPackage(Context context, InputStream in, String packageName)
            throws IOException {
        PackageInstaller packageInstaller = context.getPackageManager().getPackageInstaller();
        PackageInstaller.SessionParams params = new PackageInstaller.SessionParams(
                PackageInstaller.SessionParams.MODE_FULL_INSTALL);
        params.setAppPackageName(packageName);
        // set params
        int sessionId = packageInstaller.createSession(params);
        PackageInstaller.Session session = packageInstaller.openSession(sessionId);
        OutputStream out = session.openWrite("COSU", 0, -1);
        byte[] buffer = new byte[65536];
        int c;
        while ((c = in.read(buffer)) != -1) {
            out.write(buffer, 0, c);
        }
        session.fsync(out);
        in.close();
        out.close();

        Intent intent = new Intent(context, MainActivity.class);
        intent.putExtra("info", "somedata");  // for extra data if needed..

        Random generator = new Random();

        PendingIntent i = PendingIntent.getActivity(context, generator.nextInt(), intent,PendingIntent.FLAG_UPDATE_CURRENT);
            session.commit(i.getIntentSender());


        return true;
    }

Der folgende Code ruft die Installation auf

 try {
     InputStream is = getResources().openRawResource(R.raw.someapk_source);
                    installPackage(MainActivity.this, is, "com.example.apk");
     } catch (IOException e) {
                    Toast.makeText(MainActivity.this, e.getMessage(), Toast.LENGTH_SHORT).show();
     }

Damit das Ganze funktioniert, benötigen Sie dringend eine INSTALL_PACKAGESErlaubnis, sonst schlägt der obige Code stillschweigend fehl

<uses-permission
        android:name="android.permission.INSTALL_PACKAGES" />

Um diese Berechtigung zu erhalten, müssen Sie Ihre APK als Systemanwendung installieren, für die root erforderlich ist ( nachdem Sie jedoch Ihre Updater-Anwendung installiert haben, scheint sie OHNE root zu funktionieren).

Zur Installation als Systemanwendung habe ich ein signiertes APK erstellt und mit gepusht

adb push updater.apk /sdcard/updater.apk

und dann verschoben nach system/priv-app- was das erneute Mounten von FS erfordert (aus diesem Grund ist der Root erforderlich)

adb shell
su
mount -o rw,remount /system
mv /sdcard/updater.apk /system/priv-app
chmod 644 /system/priv-app/updater.apk

Aus irgendeinem Grund funktionierte es nicht mit der einfachen Debug-Version, aber logcat zeigt nützliche Informationen an, wenn Ihre Anwendung in priv-appaus irgendeinem Grund nicht abgeholt wird.

Sie sollten definieren

<uses-permission
    android:name="android.permission.INSTALL_PACKAGES" />

Wenn Sie sich in Ihrem Manifest in einer Systempartition (/ system / app) befinden oder Ihre Anwendung vom Hersteller signiert haben, verfügen Sie über die Berechtigung INSTALL_PACKAGES.

Mein Vorschlag ist, ein kleines Android-Projekt mit einer Kompatibilitätsstufe von 1,5 zu erstellen, mit dem installPackages über Reflection aufgerufen und ein JAR mit Methoden zum Installieren von Paketen und zum Aufrufen der realen Methoden exportiert wird. Durch Importieren des JARs in Ihr Projekt können Sie dann Pakete installieren.

Ich habe gerootetes Android 4.2.2 ausprobiert und diese Methode funktioniert für mich:

private void installApk(String filename) {
    File file = new File(filename); 
    if(file.exists()){
        try {   
            final String command = "pm install -r " + file.getAbsolutePath();
            Process proc = Runtime.getRuntime().exec(new String[] { "su", "-c", command });
            proc.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        }
     }
}

Ich hatte keine Ahnung, wie ich das machen sollte, weil diesmal niemand antwortete und ich keine Dokumentation über diese Erlaubnis fand. Also habe ich meine eigene Lösung gefunden. Es ist schlimmer als deins, aber dies ist trotzdem eine Lösung.

Ich habe eine Busybox installiert, die die 777-Berechtigung auf / data / app gesetzt hat (die Sicherheit ist mir egal). Dann einfach "Busybox Install" von der App ausgeführt. Dies funktioniert, hat aber ein großes Sicherheitsleck. Wenn Sie die Berechtigungen 777 festlegen, ist kein Root erforderlich.

Sie können die versteckte API android.content.pm.IPackageInstallObserverdurch Reflektion verwenden:

public class PackageManagement {
    public static final int INSTALL_REPLACE_EXISTING = 0x00000002;
    public static final int INSTALL_SUCCEEDED = 1;

    private static Method installPackageMethod;
    private static Method deletePackageMethod;

    static {
        try {
            installPackageMethod = PackageManager.class.getMethod("installPackage", Uri.class, IPackageInstallObserver.class, Integer.TYPE, String.class);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }

    public static void installPackage(PackageManager pm, Uri mPackageUri, IPackageInstallObserver observer, int installFlags, String installerPackageName) {
        try {
            installPackageMethod.invoke(pm, mPackageUri, observer, installFlags, installerPackageName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

android.content.pm.IPackageInstallObserverIn Ihr Projekt importieren . Ihre App muss ein System sein. Sie müssen die Berechtigung android.permission.INSTALL_PACKAGESin Ihrer Manifestdatei aktivieren .

Sie können einfach den Befehl adb install verwenden, um APK unbeaufsichtigt zu installieren / aktualisieren. Beispielcode ist unten

public static void InstallAPK(String filename){
    File file = new File(filename); 
    if(file.exists()){
        try {   
            String command;
            filename = StringUtil.insertEscape(filename);
            command = "adb install -r " + filename;
            Process proc = Runtime.getRuntime().exec(new String[] { "su", "-c", command });
            proc.waitFor();
        } catch (Exception e) {
        e.printStackTrace();
        }
     }
  }

Voraussetzung:

Ihre APK muss vom System signiert werden, wie bereits erwähnt. Eine Möglichkeit, dies zu erreichen, besteht darin, das AOSP-Image selbst zu erstellen und den Quellcode zum Build hinzuzufügen.

Code:

Nach der Installation als System-App können Sie die APK-Methoden mithilfe der Paketmanager-Methoden wie folgt installieren und deinstallieren:

Installieren:

public boolean install(final String apkPath, final Context context) {
    Log.d(TAG, "Installing apk at " + apkPath);
    try {
        final Uri apkUri = Uri.fromFile(new File(apkPath));
        final String installerPackageName = "MyInstaller";
        context.getPackageManager().installPackage(apkUri, installObserver, PackageManager.INSTALL_REPLACE_EXISTING, installerPackageName);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

Deinstallieren:

public boolean uninstall(final String packageName, final Context context) {
    Log.d(TAG, "Uninstalling package " + packageName);
    try {
        context.getPackageManager().deletePackage(packageName, deleteObserver, PackageManager.DELETE_ALL_USERS);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

Um einen Rückruf zu erhalten, sobald Ihr APK installiert / deinstalliert ist, können Sie Folgendes verwenden:

/**
 * Callback after a package was installed be it success or failure.
 */
private class InstallObserver implements IPackageInstallObserver {

    @Override
    public void packageInstalled(String packageName, int returnCode) throws RemoteException {

        if (packageName != null) {
            Log.d(TAG, "Successfully installed package " + packageName);
            callback.onAppInstalled(true, packageName);
        } else {
            Log.e(TAG, "Failed to install package.");
            callback.onAppInstalled(false, null);
        }
    }

    @Override
    public IBinder asBinder() {
        return null;
    }
}

/**
 * Callback after a package was deleted be it success or failure.
 */
private class DeleteObserver implements IPackageDeleteObserver {

    @Override
    public void packageDeleted(String packageName, int returnCode) throws RemoteException {
        if (packageName != null) {
            Log.d(TAG, "Successfully uninstalled package " + packageName);
            callback.onAppUninstalled(true, packageName);
        } else {
            Log.e(TAG, "Failed to uninstall package.");
            callback.onAppUninstalled(false, null);
        }
    }

    @Override
    public IBinder asBinder() {
        return null;
    }
}

/**
 * Callback to give the flow back to the calling class.
 */
public interface InstallerCallback {
    void onAppInstalled(final boolean success, final String packageName);
    void onAppUninstalled(final boolean success, final String packageName);
}

===> Getestet auf Android 8.1 und hat gut funktioniert.

Ich habe eine Test-App für unbeaufsichtigte Installationen mit der PackageManager.installPackage-Methode erstellt.

Ich erhalte die installPackage-Methode durch Reflektion und habe die android.content.pm.IPackageInstallObserver-Schnittstelle in meinem src-Ordner erstellt (da sie im android.content.pm-Paket versteckt ist).

Wenn ich installPackage ausführe, erhalte ich SecurityException mit der Angabe einer Zeichenfolge, dass meine App keine android.permission.INSTALL_PACKAGES hat, aber in AndroidManifest.xml definiert ist.

Ich denke, es ist nicht möglich, diese Methode zu verwenden.

PS. Ich habe in Android SDK 2.3 und 4.0 getestet. Vielleicht funktioniert es mit früheren Versionen.

Versuchen Sie dies LD_LIBRARY_PATH=/vendor/lib:/system/libvor der Installation. Es funktioniert gut.

Eine Drittanbieteranwendung kann eine Android-App nicht ohne weiteres installieren. Eine Drittanbieteranwendung kann jedoch das Android-Betriebssystem auffordern, eine Anwendung zu installieren.

Sie sollten dies also definieren:

Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setDataAndType(Uri.parse("file:///sdcard/app.apk", "application/vnd.android.package-archive");
startActivity(intent);

Sie können auch versuchen, es als System-App zu installieren, um die Berechtigung zu erteilen und diese Definition zu ignorieren. (Root erforderlich)

Sie können den folgenden Befehl auf Ihrer Drittanbieter-App ausführen, um eine App auf dem gerooteten Gerät zu installieren.

Der Code lautet:

private void installApk(String filename) {
File file = new File(filename); 
if(file.exists()){
    try {   
        final String command = "pm install -r " + file.getAbsolutePath();
        Process proc = Runtime.getRuntime().exec(new String[] { "su", "-c", command });
        proc.waitFor();
    } catch (Exception e) {
        e.printStackTrace();
    }
 }
}

Ich hoffe, dass diese Antwort für Sie hilfreich ist.

Es ist möglich, eine stille Installation unter Android 6 und höher durchzuführen. Ignorieren Sie mit der in der Antwort von Boris Treukhov angegebenen Funktion alles andere im Beitrag. Root ist ebenfalls nicht erforderlich.

Installieren Sie Ihre App als Geräteadministrator. Sie können den vollständigen Kioskmodus mit der unbeaufsichtigten Installation von Updates im Hintergrund nutzen.

Ich habe alle Antworten überprüft. Die Schlussfolgerung scheint zu sein, dass Sie zuerst Root-Zugriff auf das Gerät haben müssen, damit es funktioniert.

Aber dann fand ich diese Artikel sehr nützlich. Da mache ich "firmeneigene" Geräte.

So aktualisieren Sie die Android App lautlos ohne Benutzerinteraktion

Android-Gerätebesitzer - Minimal App

Hier ist die Dokumentation von Google über "Managed Device".

Vollständig verwaltetes Gerät

! / bin / bash

f=/home/cox/myapp.apk   #or $1 if input from terminal.

#backup env var
backup=$LD_LIBRARY_PATH
LD_LIBRARY_PATH=/vendor/lib:/system/lib
myTemp=/sdcard/temp.apk
adb push $f $myTemp
adb shell pm install -r $myTemp
#restore env var
LD_LIBRARY_PATH=$backup

Das funktioniert bei mir. Ich führe dies auf Ubuntu 12.04 auf dem Shell-Terminal aus.