본문 바로가기
Android/Android 기초

[Android] Context 딥 다이브 (2) - 내부 메소드 종류

by 태크민 2025. 2. 26.

지난 포스팅(https://jtm0609.tistory.com/300)에서는 Context 개념에 대해서 살펴보았습니다.

이번 포스팅에서는 추상클래스인 Context가 가지고 있는 api와 메소드들을 살펴보겠습니다.

 

Context.java 소스 코드 {docs}

Context.java 는 frameworks/base/core/java/android/content 패키지에 존재합니다. Context.java에는 아래와 같은 정보를 가지고 있습니다.

  • 플래그 정보
  • 리소스, Theme 정보
  • PackageManager, MainLooper 정보
  • Activity, Service, Broadcast, ContentResoler 정보
  • ApplicationContext 정보 및 각종 Context에 대한 생성 로직
  • Application 및 Package정보
  • SharedPreference, File, Sqlite 등 추상화
  • Permission 정보
  • Display 정보

플래그 정보

Context.java 상단에는 각종 enum 타입과 상수들을 볼 수 있습니다. 이 플래그 값들은 Context 인스턴스를 가지고 있다면 언제든지 접근할 수 있습니다.

public static final int MODE_PRIVATE = 0x0000;
public static final int MODE_APPEND = 0x8000;
public static final int MODE_ENABLE_WRITE_AHEAD_LOGGING = 0x0008;
public static final int MODE_NO_LOCALIZED_COLLATORS = 0x0010;
public static final int BIND_AUTO_CREATE = 0x0001;
public static final int BIND_DEBUG_UNBIND = 0x0002;
public static final int BIND_NOT_FOREGROUND = 0x0004;
public static final int BIND_ABOVE_CLIENT = 0x0008;
public static final int BIND_ALLOW_OOM_MANAGEMENT = 0x0010;
public static final int BIND_WAIVE_PRIORITY = 0x0020;
public static final int BIND_IMPORTANT = 0x0040;
public static final int BIND_ADJUST_WITH_ACTIVITY = 0x0080;
public static final int BIND_NOT_PERCEPTIBLE = 0x00000100;
public static final int BIND_INCLUDE_CAPABILITIES = 0x000001000;
/***********    Public flags above this line ***********/

/***********    Hidden flags below this line ***********/
public static final int BIND_NOT_APP_COMPONENT_USAGE = 0x00008000;
public static final int BIND_ALMOST_PERCEPTIBLE = 0x000010000;
public static final int BIND_BYPASS_POWER_NETWORK_RESTRICTIONS = 0x00020000;
public static final int BIND_SCHEDULE_LIKE_TOP_APP = 0x00080000;
..(길어서 생략)

 

하지만 코드 중간에 아래와 같은 주석을 볼 수 있습니다.

/***********    Public flags above this line ***********/
/***********    Hidden flags below this line ***********/

 

위 주석 위에 있는 플래그는 public 하지만 하단의 플래그 들은 Hidden되어 있다는 것을 알 수 있습니다. 

Hidden은 안드로이드 프레임워크에서는 접근이 가능하지만,  애플리케이션 레벨에서는 접근이 불가능 하다는 것을 의미합니다.

 

리소스

다음은 리소스와 관련된 코드들을 볼 수 있습니다. 안드로이드는 앱에서 사용되는 리소스를 소스 코드가 아닌 별도 리소스 폴더로 관리하고 있습니다. 소스 코드에서 필요한 리소스를 쉽게 참조 할 수 있도록 Resource 클래스를 제공하고 있습니다

Context는 Resource 인스턴스를 참조 할 수 있도록 요구하고 있습니다. Context 인스턴스를 가지고 있다면 Resouces와 AssetManager를 참조할 수 있도록 보장해줍니다. 

    public abstract AssetManager getAssets();

    public abstract Resources getResources();
    
    @NonNull
    public final CharSequence getText(@StringRes int resId) {
        return getResources().getText(resId);
    }

    @NonNull
    public final String getString(@StringRes int resId) {
        return getResources().getString(resId);
    }

    @NonNull
    public final String getString(@StringRes int resId, Object... formatArgs) {
        return getResources().getString(resId, formatArgs);
    }

    @ColorInt
    public final int getColor(@ColorRes int id) {
        return getResources().getColor(id, getTheme());
    }

    @Nullable
    public final Drawable getDrawable(@DrawableRes int id) {
        return getResources().getDrawable(id, getTheme());
    }

    @NonNull
    public final ColorStateList getColorStateList(@ColorRes int id) {
        return getResources().getColorStateList(id, getTheme());
    }

 

우리는 엑티비티에서 리소스를 가져오기 위해서 getString, getColor와 같은 api를 호출 했습니다. 이는 사실 Context내에서 Resources 객체로 위임해주고 있다는 사실을 코드를 통해서 알 수 있습니다.

 

PackageManager, ContentResolver, MainLooper 등

리소스 뿐만 아니라 Context는 PackageManager, ContentResolver, MainLooper에 대한 구현을 요구합니다.

Context 인스턴스를 통해서 리소스 객체 뿐만 아니라 PackageManager, ContentResolver, MainLooper에 대한 참조도 할 수 있습니다.

    public abstract PackageManager getPackageManager();

    public abstract ContentResolver getContentResolver();

    public abstract Looper getMainLooper();

    public Executor getMainExecutor() {
        return new HandlerExecutor(new Handler(getMainLooper()));
    }

 

ApplicationContext

Context 중에는 applicationContext 를 반환하도록 요구하는 api도 존재합니다.

public abstract Context getApplicationContext();

 

Context에서 applicationContext를 api로 제공한 이유는 무엇일까요? 공식 문서는 다음과 같습니다.

 

번역하면 아래와 같습니다.

 

현재 프로세스의 단일 전역 Application 개체의 컨텍스트를 반환합니다. 이것은 일반적으로 현재 구성 요소가 아닌 프로세스의 수명에 연결된 현재 컨텍스트와 별도의 수명 주기를 가진 컨텍스트가 필요한 경우에만 사용해야 합니다.

 

안드로이드에서 BroadcastReceiver를 등록할 때 activityContext로 등록하는 경우 actvity 생명주기가 종료되는 시점에 activityContext 또한 폐기 됩니다. 이는 BroadcastReceiver 또한 해제되는 동작으로 이어지게 됩니다. 하지만 위 api에서 applicationContext를 정상적으로 반환한다면 BroadcastReceiver를 해제하는 것이 아닌 applicationContext로 수정할 수 있게 됩니다.

 

하지만 ApplicationContext를 참조하면 메모리 릭의 원인이 될 수 있기 때문에 unregiester를 잊으면 안됩니다.

 

Theme

다음으로 getTheme/setTheme에 대한 추상메소드가 존재합니다. context는 theme에 대한 동작을 서브 클래스에서 구현하도록 요구합니다.

    public abstract void setTheme(@StyleRes int resid);

    @UnsupportedAppUsage
    public int getThemeResId() {
        return 0;
    }

    @ViewDebug.ExportedProperty(deepExport = true)
    public abstract Resources.Theme getTheme();

    @NonNull
    public final TypedArray obtainStyledAttributes(@NonNull @StyleableRes int[] attrs) {
        return getTheme().obtainStyledAttributes(attrs);
    }

    @NonNull
    public final TypedArray obtainStyledAttributes(@StyleRes int resid,
            @NonNull @StyleableRes int[] attrs) throws Resources.NotFoundException {
        return getTheme().obtainStyledAttributes(resid, attrs);
    }

    @NonNull
    public final TypedArray obtainStyledAttributes(
            @Nullable AttributeSet set, @NonNull @StyleableRes int[] attrs) {
        return getTheme().obtainStyledAttributes(set, attrs, 0, 0);
    }

    @NonNull
    public final TypedArray obtainStyledAttributes(@Nullable AttributeSet set,
            @NonNull @StyleableRes int[] attrs, @AttrRes int defStyleAttr,
            @StyleRes int defStyleRes) {
        return getTheme().obtainStyledAttributes(
            set, attrs, defStyleAttr, defStyleRes);
    }

 

Application / Package 정보

Context는 ClassLoader, PackageName, basePackageName, applicationInfo applicationResourcePath, packageCodePath 등 현재 애플리케이션의 정보를 반환하도록 요구하고 있습니다. 이러한 구현을 통해서 현재 Context는 어떤 패키지의 어플리케이션이며 코드와 리소스에 대한 위치도 알 수 있게 됩니다.

    public abstract ClassLoader getClassLoader();

    public abstract String getPackageName();

    @SuppressWarnings("HiddenAbstractMethod")
    @UnsupportedAppUsage
    public abstract String getBasePackageName();

    @NonNull
    public String getOpPackageName() {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    public @Nullable String getAttributionTag() {
        return null;
    }

    public @NonNull AttributionSource getAttributionSource() {
        return null;
    }

    public @Nullable ContextParams getParams() {
        return null;
    }

    public abstract ApplicationInfo getApplicationInfo();


    public abstract String getPackageResourcePath();

    public abstract String getPackageCodePath();

 

SharedPreference

SharedPreference에 대한 코드를 확인할 수 있습니다. context를 통해서 SharePreferences에 접근할 수 있습니다.

public abstract SharedPreferences getSharedPreferences(String name, @PreferencesMode int mode);

public abstract boolean moveSharedPreferencesFrom(Context sourceContext, String name);

public abstract boolean deleteSharedPreferences(String name);

@SuppressWarnings("HiddenAbstractMethod")
public abstract void reloadSharedPreferences();

 

File I/O

File과 관련된 코드들 도 확인할 수 있습니다. Android는 Context를 통해서 file 생성/삭제 로직을 제공합니다.

    public abstract FileInputStream openFileInput(String name)
        throws FileNotFoundException;

    public abstract FileOutputStream openFileOutput(String name, @FileMode int mode)
        throws FileNotFoundException;

    public abstract boolean deleteFile(String name);

    public abstract File getFileStreamPath(String name);

    public abstract File getDataDir();

    public abstract File getFilesDir();

    @NonNull
    @TestApi
    public File getCrateDir(@NonNull String crateId) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    public abstract File getNoBackupFilesDir();

    @Nullable
    public abstract File getExternalFilesDir(@Nullable String type);

    public abstract File[] getExternalFilesDirs(String type);

    public abstract File getObbDir();


    public abstract File[] getObbDirs();


    public abstract File getCacheDir();


    public abstract File getCodeCacheDir();

    @Nullable
    public abstract File getExternalCacheDir();

    @SuppressWarnings("HiddenAbstractMethod")
    @Nullable
    @SystemApi
    public abstract File getPreloadsFileCache();

    public abstract File[] getExternalCacheDirs();

    public abstract String[] fileList();

    public abstract File getDir(String name, @FileMode int mode);

 

Database

Context는 SQLiteDatabase에 대한 의존을 가지고 있습니다. SQLiteDatabase를 조작하는 함수들을 추상화하여 서브 클래스에서 구현하도록 하였습니다.

    public abstract SQLiteDatabase openOrCreateDatabase(String name,
            @DatabaseMode int mode, CursorFactory factory);

    public abstract SQLiteDatabase openOrCreateDatabase(String name,
            @DatabaseMode int mode, CursorFactory factory,
            @Nullable DatabaseErrorHandler errorHandler);

    public abstract boolean moveDatabaseFrom(Context sourceContext, String name);

    public abstract boolean deleteDatabase(String name);

    public abstract File getDatabasePath(String name);

    public abstract String[] databaseList();

 

StartActivity

Activity 전환에 사용되는 startActivity에 대한 추상 메소드를 정의하고 있습니다.

    public abstract void startActivity(@RequiresPermission Intent intent);

    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    @SystemApi
    public void startActivityAsUser(@RequiresPermission @NonNull Intent intent,
            @NonNull UserHandle user) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    public abstract void startActivity(@RequiresPermission Intent intent,
            @Nullable Bundle options);

    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    @SystemApi
    public void startActivityAsUser(@RequiresPermission @NonNull Intent intent,
            @Nullable Bundle options, @NonNull UserHandle userId) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    @UnsupportedAppUsage
    public void startActivityForResult(
            @NonNull String who, Intent intent, int requestCode, @Nullable Bundle options) {
        throw new RuntimeException("This method is only implemented for Activity-based Contexts. "
                + "Check canStartActivityForResult() before calling.");
    }

    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    public boolean canStartActivityForResult() {
        return false;
    }

    public abstract void startActivities(@RequiresPermission Intent[] intents);

    public abstract void startActivities(@RequiresPermission Intent[] intents, Bundle options);

    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    public int startActivitiesAsUser(Intent[] intents, Bundle options, UserHandle userHandle) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

 

BroadcastReceiver

Context는 Broadcast를 보내고, Receiver를 등록하는 과정들을 추상화 하여 제공하고 있습니다.

  public abstract void sendBroadcast(@RequiresPermission Intent intent);
    public abstract void sendBroadcast(@RequiresPermission Intent intent,
            @Nullable String receiverPermission);

    public void sendBroadcastMultiplePermissions(@NonNull Intent intent,
            @NonNull String[] receiverPermissions) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }
    public void sendBroadcastMultiplePermissions(@NonNull Intent intent,
            @NonNull String[] receiverPermissions, @Nullable String[] excludedPermissions) {
        sendBroadcastMultiplePermissions(intent, receiverPermissions, excludedPermissions, null);
    }
    public void sendBroadcastMultiplePermissions(@NonNull Intent intent,
            @NonNull String[] receiverPermissions, @Nullable String[] excludedPermissions,
            @Nullable String[] excludedPackages) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }
    public void sendBroadcastMultiplePermissions(@NonNull Intent intent,
            @NonNull String[] receiverPermissions, @Nullable Bundle options) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }
    @SystemApi
    public void sendBroadcastMultiplePermissions(@NonNull Intent intent,
            @NonNull String[] receiverPermissions, @Nullable BroadcastOptions options) {
       sendBroadcastMultiplePermissions(intent, receiverPermissions, options.toBundle());
    }
    public void sendBroadcastWithMultiplePermissions(@NonNull Intent intent,
            @NonNull String[] receiverPermissions) {
        sendBroadcastMultiplePermissions(intent, receiverPermissions);
    }
    @SuppressWarnings("HiddenAbstractMethod")
    public abstract void sendBroadcastAsUserMultiplePermissions(Intent intent, UserHandle user,
            String[] receiverPermissions);
    @SuppressWarnings("HiddenAbstractMethod")
    @SystemApi
    public abstract void sendBroadcast(Intent intent,
            @Nullable String receiverPermission,
            @Nullable Bundle options);
    @SuppressWarnings("HiddenAbstractMethod")
    @UnsupportedAppUsage
    public abstract void sendBroadcast(Intent intent,
            String receiverPermission, int appOp);
    public abstract void sendOrderedBroadcast(@RequiresPermission Intent intent,
            @Nullable String receiverPermission);
    public abstract void sendOrderedBroadcast(@RequiresPermission @NonNull Intent intent,
            @Nullable String receiverPermission, @Nullable BroadcastReceiver resultReceiver,
            @Nullable Handler scheduler, int initialCode, @Nullable String initialData,
            @Nullable Bundle initialExtras);
    @SuppressWarnings("HiddenAbstractMethod")
    @SystemApi
    public abstract void sendOrderedBroadcast(@NonNull Intent intent,
            @Nullable String receiverPermission, @Nullable Bundle options,
            @Nullable BroadcastReceiver resultReceiver, @Nullable Handler scheduler,
            int initialCode, @Nullable String initialData, @Nullable Bundle initialExtras);

    @SuppressWarnings("HiddenAbstractMethod")
    @UnsupportedAppUsage
    public abstract void sendOrderedBroadcast(Intent intent,
            String receiverPermission, int appOp, BroadcastReceiver resultReceiver,
            Handler scheduler, int initialCode, String initialData,
            Bundle initialExtras);

    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    public abstract void sendBroadcastAsUser(@RequiresPermission Intent intent,
            UserHandle user);

    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    public abstract void sendBroadcastAsUser(@RequiresPermission Intent intent,
            UserHandle user, @Nullable String receiverPermission);

    @SuppressWarnings("HiddenAbstractMethod")
    @SystemApi
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    public abstract void sendBroadcastAsUser(@RequiresPermission Intent intent,
            UserHandle user, @Nullable String receiverPermission, @Nullable Bundle options);

    @SuppressWarnings("HiddenAbstractMethod")
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    public abstract void sendBroadcastAsUser(@RequiresPermission Intent intent,
            UserHandle user, @Nullable String receiverPermission, int appOp);

    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    public abstract void sendOrderedBroadcastAsUser(@RequiresPermission Intent intent,
            UserHandle user, @Nullable String receiverPermission, BroadcastReceiver resultReceiver,
            @Nullable Handler scheduler, int initialCode, @Nullable String initialData,
            @Nullable  Bundle initialExtras);

    @SuppressWarnings("HiddenAbstractMethod")
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    public abstract void sendOrderedBroadcastAsUser(Intent intent, UserHandle user,
            @Nullable String receiverPermission, int appOp, BroadcastReceiver resultReceiver,
            @Nullable Handler scheduler, int initialCode, @Nullable String initialData,
            @Nullable  Bundle initialExtras);

    @SuppressWarnings("HiddenAbstractMethod")
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
    @UnsupportedAppUsage
    public abstract void sendOrderedBroadcastAsUser(Intent intent, UserHandle user,
            @Nullable String receiverPermission, int appOp, @Nullable Bundle options,
            BroadcastReceiver resultReceiver, @Nullable Handler scheduler, int initialCode,
            @Nullable String initialData, @Nullable  Bundle initialExtras);

    public void sendOrderedBroadcast(@NonNull Intent intent, @Nullable String receiverPermission,
            @Nullable String receiverAppOp, @Nullable BroadcastReceiver resultReceiver,
            @Nullable Handler scheduler, int initialCode, @Nullable String initialData,
            @Nullable Bundle initialExtras) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    public void sendOrderedBroadcast(@RequiresPermission @NonNull Intent intent, int initialCode,
            @Nullable String receiverPermission, @Nullable String receiverAppOp,
            @Nullable BroadcastReceiver resultReceiver, @Nullable Handler scheduler,
            @Nullable String initialData, @Nullable Bundle initialExtras,
            @Nullable Bundle options) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    @Nullable
    public abstract Intent registerReceiver(@Nullable BroadcastReceiver receiver,
                                            IntentFilter filter);

    @Nullable
    public abstract Intent registerReceiver(@Nullable BroadcastReceiver receiver,
                                            IntentFilter filter,
                                            @RegisterReceiverFlags int flags);
    @Nullable
    public abstract Intent registerReceiver(BroadcastReceiver receiver,
            IntentFilter filter, @Nullable String broadcastPermission,
            @Nullable Handler scheduler);

    @Nullable
    public abstract Intent registerReceiver(BroadcastReceiver receiver,
            IntentFilter filter, @Nullable String broadcastPermission,
            @Nullable Handler scheduler, @RegisterReceiverFlags int flags);

    @Nullable
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
    @SystemApi
    public Intent registerReceiverForAllUsers(@Nullable BroadcastReceiver receiver,
            @NonNull IntentFilter filter, @Nullable String broadcastPermission,
            @Nullable Handler scheduler) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }
    @SuppressLint("IntentBuilderName")
    @Nullable
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
    @SystemApi
    public Intent registerReceiverForAllUsers(@Nullable BroadcastReceiver receiver,
            @NonNull IntentFilter filter, @Nullable String broadcastPermission,
            @Nullable Handler scheduler, @RegisterReceiverFlags int flags) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }
    @SuppressWarnings("HiddenAbstractMethod")
    @Nullable
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
    @UnsupportedAppUsage
    public abstract Intent registerReceiverAsUser(BroadcastReceiver receiver,
            UserHandle user, IntentFilter filter, @Nullable String broadcastPermission,
            @Nullable Handler scheduler);
    @SuppressWarnings("HiddenAbstractMethod")
    @SuppressLint("IntentBuilderName")
    @Nullable
    @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS_FULL)
    @UnsupportedAppUsage
    public abstract Intent registerReceiverAsUser(BroadcastReceiver receiver,
            UserHandle user, IntentFilter filter, @Nullable String broadcastPermission,
            @Nullable Handler scheduler, @RegisterReceiverFlags int flags);

    public abstract void unregisterReceiver(BroadcastReceiver receiver);

 

Service

context에는 Service에 대한 제어를 위해 추상 메소드로 정의하여 서브 클래스에서 이를 구현하고 앱은 추상화된 context api로 서비스를 제어할 수 있습니다.

@Nullable
public abstract ComponentName startService(Intent service);

@Nullable
public abstract ComponentName startForegroundService(Intent service);

@SuppressWarnings("HiddenAbstractMethod")
@Nullable
@RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
public abstract ComponentName startForegroundServiceAsUser(Intent service, UserHandle user);

public abstract boolean stopService(Intent service);

@SuppressWarnings("HiddenAbstractMethod")
@Nullable
@RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
@UnsupportedAppUsage
public abstract ComponentName startServiceAsUser(Intent service, UserHandle user);

@SuppressWarnings("HiddenAbstractMethod")
@RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS)
public abstract boolean stopServiceAsUser(Intent service, UserHandle user);

public abstract boolean bindService(@RequiresPermission Intent service,
        @NonNull ServiceConnection conn, @BindServiceFlags int flags);

public boolean bindService(@RequiresPermission @NonNull Intent service,
        @BindServiceFlags int flags, @NonNull @CallbackExecutor Executor executor,
        @NonNull ServiceConnection conn) {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

public boolean bindIsolatedService(@RequiresPermission @NonNull Intent service,
        @BindServiceFlags int flags, @NonNull String instanceName,
        @NonNull @CallbackExecutor Executor executor, @NonNull ServiceConnection conn) {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

@SuppressWarnings("unused")
@RequiresPermission(anyOf = {
        android.Manifest.permission.INTERACT_ACROSS_USERS,
        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
        android.Manifest.permission.INTERACT_ACROSS_PROFILES
        }, conditional = true)
public boolean bindServiceAsUser(
        @NonNull @RequiresPermission Intent service, @NonNull ServiceConnection conn, int flags,
        @NonNull UserHandle user) {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

@RequiresPermission(anyOf = {
        android.Manifest.permission.INTERACT_ACROSS_USERS,
        android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
        android.Manifest.permission.INTERACT_ACROSS_PROFILES
        }, conditional = true)
@UnsupportedAppUsage(trackingBug = 136728678)
public boolean bindServiceAsUser(Intent service, ServiceConnection conn, int flags,
        Handler handler, UserHandle user) {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

public void updateServiceGroup(@NonNull ServiceConnection conn, int group,
        int importance) {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

public abstract void unbindService(@NonNull ServiceConnection conn);
..(길어서 생략)

 

Permission

Context는 Permission에 대한 api도 추상화 하고 있습니다.

   @CheckResult(suggest="#enforcePermission(String,int,int,String)")
    @PackageManager.PermissionResult
    public abstract int checkPermission(@NonNull String permission, int pid, int uid);

    /** @hide */
    @SuppressWarnings("HiddenAbstractMethod")
    @PackageManager.PermissionResult
    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
    public abstract int checkPermission(@NonNull String permission, int pid, int uid,
            IBinder callerToken);

    @CheckResult(suggest="#enforceCallingPermission(String,String)")
    @PackageManager.PermissionResult
    public abstract int checkCallingPermission(@NonNull String permission);

    @CheckResult(suggest="#enforceCallingOrSelfPermission(String,String)")
    @PackageManager.PermissionResult
    public abstract int checkCallingOrSelfPermission(@NonNull String permission);

    @PackageManager.PermissionResult
    public abstract int checkSelfPermission(@NonNull String permission);

    public abstract void enforcePermission(
            @NonNull String permission, int pid, int uid, @Nullable String message);

    public abstract void enforceCallingPermission(
            @NonNull String permission, @Nullable String message);

    public abstract void enforceCallingOrSelfPermission(
            @NonNull String permission, @Nullable String message);

    public abstract void grantUriPermission(String toPackage, Uri uri,
            @Intent.GrantUriMode int modeFlags);

    public abstract void revokeUriPermission(Uri uri, @Intent.AccessUriMode int modeFlags);

    public abstract void revokeUriPermission(String toPackage, Uri uri,
            @Intent.AccessUriMode int modeFlags);

    @CheckResult(suggest="#enforceUriPermission(Uri,int,int,String)")
    @PackageManager.PermissionResult
    public abstract int checkUriPermission(Uri uri, int pid, int uid,
            @Intent.AccessUriMode int modeFlags);

    @NonNull
    @PackageManager.PermissionResult
    public int[] checkUriPermissions(@NonNull List<Uri> uris, int pid, int uid,
            @Intent.AccessUriMode int modeFlags) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    /** @hide */
    @SuppressWarnings("HiddenAbstractMethod")
    @PackageManager.PermissionResult
    public abstract int checkUriPermission(Uri uri, int pid, int uid,
            @Intent.AccessUriMode int modeFlags, IBinder callerToken);

    @CheckResult(suggest="#enforceCallingUriPermission(Uri,int,String)")
    @PackageManager.PermissionResult
    public abstract int checkCallingUriPermission(Uri uri, @Intent.AccessUriMode int modeFlags);

    @NonNull
    @PackageManager.PermissionResult
    public int[] checkCallingUriPermissions(@NonNull List<Uri> uris,
            @Intent.AccessUriMode int modeFlags) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    @CheckResult(suggest="#enforceCallingOrSelfUriPermission(Uri,int,String)")
    @PackageManager.PermissionResult
    public abstract int checkCallingOrSelfUriPermission(Uri uri,
            @Intent.AccessUriMode int modeFlags);

    @NonNull
    @PackageManager.PermissionResult
    public int[] checkCallingOrSelfUriPermissions(@NonNull List<Uri> uris,
            @Intent.AccessUriMode int modeFlags) {
        throw new RuntimeException("Not implemented. Must override in a subclass.");
    }

    @CheckResult(suggest="#enforceUriPermission(Uri,String,String,int,int,int,String)")
    @PackageManager.PermissionResult
    public abstract int checkUriPermission(@Nullable Uri uri, @Nullable String readPermission,
            @Nullable String writePermission, int pid, int uid,
            @Intent.AccessUriMode int modeFlags);

    public abstract void enforceUriPermission(
            Uri uri, int pid, int uid, @Intent.AccessUriMode int modeFlags, String message);

    public abstract void enforceCallingUriPermission(
            Uri uri, @Intent.AccessUriMode int modeFlags, String message);

    public abstract void enforceCallingOrSelfUriPermission(
            Uri uri, @Intent.AccessUriMode int modeFlags, String message);

    public abstract void enforceUriPermission(
            @Nullable Uri uri, @Nullable String readPermission,
            @Nullable String writePermission, int pid, int uid, @Intent.AccessUriMode int modeFlags,
            @Nullable String message);

    public void revokeSelfPermissionOnKill(@NonNull String permName) {
        revokeSelfPermissionsOnKill(Collections.singletonList(permName));
    }
    public void revokeSelfPermissionsOnKill(@NonNull Collection<String> permissions) {
        throw new AbstractMethodError("Must be overridden in implementing class");

 

Display

@SuppressWarnings("HiddenAbstractMethod")
public abstract DisplayAdjustments getDisplayAdjustments(int displayId);

@Nullable
public Display getDisplay() {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

@Nullable
public Display getDisplayNoVerify() {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

@SuppressWarnings("HiddenAbstractMethod")
@TestApi
public abstract int getDisplayId();

public int getAssociatedDisplayId() {
    throw new RuntimeException("Not implemented. Must override in a subclass.");
}

@SuppressWarnings("HiddenAbstractMethod")
public abstract void updateDisplay(int displayId);

 

 

끝.

 

읽어주셔서 감사합니다.

출처

https://quokkaman.medium.com/android-context-java-%EC%82%B4%ED%8E%B4%EB%B3%B4%EA%B8%B0-99af2b4bfe7f

 

Android — Context.java 살펴보기

추상클래스인 Context가 가지고 있는 api와 메소드들을 살펴봅니다.

quokkaman.medium.com

 

'Android > Android 기초' 카테고리의 다른 글

[Android] Bundle의 용량 (feat. TransactionTooLargeException)  (0) 2025.03.13
[Android] 핸들러(Handler)와 루퍼(Looper)  (0) 2025.02.27
[Android] Context 딥 다이브 (1) - Context란?  (0) 2025.02.26
[Android] 안드로이드 Binder(IPC) 구현하기  (0) 2025.02.25
[Android] 안드로이드의 바인더(IPC)란?  (0) 2025.02.25

관련글

티스토리툴바