fastlane-plugin-google_play_track_updater 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11eadb84667aef723c783a8dcffa26780b405708ff266657ddacc2a8d7f91d2f
+  data.tar.gz: f680a23a1d846440ca71559f04d20636e0faeb95729471b700deaa879c16f3cd
+SHA512:
+  metadata.gz: '08cc54c3f46d2a9748e21a7de9eb83bfd024f5ad176b00f7144a38bdec1b9787982bc30b71d818dbe7a850ea14367c83abe7f2be46e6258854d12e6a54d200d8'
+  data.tar.gz: defce589cb05520229a89060ca58073c2e7e59ec9ef1abaec5a332b9854b324f96969bdd22042d633ebd7a9c5b18451f051fbc2fea8adaec6473163d3c9505cf

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Takuma Homma <nagomimatcha@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# google_play_track_updater plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-google_play_track_updater)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-google_play_track_updater`, add it to your project by running:
+
+```bash
+# to Gemfile
+bundle add 'fastlane-plugin-google_play_track_updater'
+```
+
+```bash
+# to Pluginfile
+fastlane add_plugin google_play_track_updater
+```
+
+## About google_play_track_updater
+
+A fastlane plugin for managing Google Play release tracks. This plugin provides three actions to control release statuses and rollout fractions:
+
+- **`halt_google_play_release`** - Halts an active staged rollout or completed release
+- **`resume_google_play_release`** - Resumes a halted release
+- **`update_google_play_release_rollout`** - Updates the rollout percentage for a staged rollout
+
+## Motivation
+
+While [supply](https://docs.fastlane.tools/actions/supply/) can also change release statuses, it requires many configuration parameters which can lead to unintended side effects. This plugin provides dedicated actions for each specific operation, making release management more explicit and manageable.
+
+By using focused actions like `halt_google_play_release`, `resume_google_play_release`, and `update_google_play_release_rollout`, you can:
+
+- Clearly express your intent in your Fastfile
+- Reduce the risk of accidentally modifying other release properties
+- Simplify your CI/CD pipelines with purpose-built commands
+
+## Actions
+
+### halt_google_play_release
+
+Halts an active staged rollout or completed release for a specific version on a Google Play track.
+
+```ruby
+halt_google_play_release(
+  package_name: "com.example.app",
+  track: "production",
+  version_name: "1.0.0",
+  json_file_path: "path/to/service-account.json"
+)
+```
+
+**Parameters:**
+
+| Key | Description | Required | Type |
+|-----|-------------|----------|------|
+| `package_name` | The package name of the application (e.g., 'com.example.app') | Yes | String |
+| `track` | The track of the application (production, beta, alpha, internal) | Yes | String |
+| `version_name` | The version name to halt (e.g., '1.0.0') | Yes | String |
+| `json_file_path` | Path to a file containing service account or external account JSON | No* | String |
+| `json_key_data` | Service account or external account JSON data as a string | No* | String |
+
+\* Either `json_file_path` or `json_key_data` must be provided
+
+### resume_google_play_release
+
+Resumes a halted staged rollout for a specific version on a Google Play track. The status will change from 'halted' to either 'completed' (if no user_fraction is set) or 'inProgress' (if user_fraction is set for staged rollout).
+
+```ruby
+resume_google_play_release(
+  package_name: "com.example.app",
+  track: "production",
+  version_name: "1.0.0",
+  json_file_path: "path/to/service-account.json"
+)
+```
+
+**Parameters:**
+
+| Key | Description | Required | Type |
+|-----|-------------|----------|------|
+| `package_name` | The package name of the application (e.g., 'com.example.app') | Yes | String |
+| `track` | The track of the application (production, beta, alpha, internal) | Yes | String |
+| `version_name` | The version name to resume (e.g., '1.0.0') | Yes | String |
+| `json_file_path` | Path to a file containing service account or external account JSON | No* | String |
+| `json_key_data` | Service account or external account JSON data as a string | No* | String |
+
+\* Either `json_file_path` or `json_key_data` must be provided
+
+### update_google_play_release_rollout
+
+Updates the rollout percentage for a staged rollout on a Google Play track. Only updates releases with 'inProgress' status.
+
+```ruby
+update_google_play_release_rollout(
+  package_name: "com.example.app",
+  track: "production",
+  version_name: "1.0.0",
+  user_fraction: 0.5, # 50% rollout
+  json_file_path: "path/to/service-account.json"
+)
+```
+
+**Parameters:**
+
+| Key | Description | Required | Type |
+|-----|-------------|----------|------|
+| `package_name` | The package name of the application (e.g., 'com.example.app') | Yes | String |
+| `track` | The track of the application (production, beta, alpha, internal) | Yes | String |
+| `version_name` | The version name to update (e.g., '1.0.0') | Yes | String |
+| `user_fraction` | The rollout percentage as a fraction (0.0 to 1.0, exclusive). e.g., 0.1 for 10% rollout | Yes | Float |
+| `json_file_path` | Path to a file containing service account or external account JSON | No* | String |
+| `json_key_data` | Service account or external account JSON data as a string | No* | String |
+
+\* Either `json_file_path` or `json_key_data` must be provided
+
+## Example
+
+Here are examples of how to use each action in your `Fastfile`:
+
+```ruby
+lane :halt_release do
+  halt_google_play_release(
+    package_name: "com.example.app",
+    track: "production",
+    version_name: "1.0.0",
+    json_file_path: "path/to/service-account.json"
+  )
+end
+
+lane :resume_release do
+  resume_google_play_release(
+    package_name: "com.example.app",
+    track: "production",
+    version_name: "1.0.0",
+    json_file_path: "path/to/external-account.json"
+  )
+end
+
+lane :update_rollout do
+  update_google_play_release_rollout(
+    package_name: "com.example.app",
+    track: "production",
+    version_name: "1.0.0",
+    user_fraction: 0.5,
+    json_file_path: "path/to/service-account.json"
+  )
+end
+```
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/google_play_track_updater/actions/halt_google_play_release_action.rb

@@ -0,0 +1,81 @@
+require 'fastlane/action'
+require_relative '../client'
+
+module Fastlane
+  module Actions
+    class HaltGooglePlayReleaseAction < Action
+      def self.run(params)
+        package_name = params[:package_name]
+        track = params[:track]
+        version_name = params[:version_name]
+        json_file_path = params[:json_file_path]
+        json_key_data = params[:json_key_data]
+        client = Fastlane::GooglePlayTrackUpdater::GooglePlayClient.new(
+          json_file_path: json_file_path,
+          json_key_data: json_key_data
+        )
+        client.halt_release(
+          package_name: package_name,
+          track: track,
+          version_name: version_name
+        )
+      end
+
+      def self.description
+        'Halts an active staged rollout or completed for a specific version on a Google Play track.'
+      end
+
+      def self.authors
+        ['Takuma Homma']
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        'Halts an active staged rollout or completed for a specific version on a Google Play track.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :package_name,
+                                       env_name: 'HALT_GOOGLE_PLAY_RELEASE_PACKAGE_NAME',
+                                       description: 'The package name of the application. e.g. \'com.example.app\'',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :track,
+                                       env_name: "HALT_GOOGLE_PLAY_RELEASE_TRACK",
+                                       description: 'The track of the application. The available tracks are: production, beta, alpha, internal',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :version_name,
+                                       env_name: 'HALT_GOOGLE_PLAY_RELEASE_VERSION_NAME',
+                                       description: 'The version name to update. e.g. \'1.0.0\'',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :json_file_path,
+                                       env_name: 'HALT_GOOGLE_PLAY_RELEASE_JSON_FILE_PATH',
+                                       description: 'The path to a file containing service account or external account JSON, used to authenticate with Google',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :json_key_data,
+                                       env_name: 'HALT_GOOGLE_PLAY_RELEASE_JSON_KEY_DATA',
+                                       description: 'The file data containing service account or external account JSON, used to authenticate with Google',
+                                       optional: true,
+                                       type: String)
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/google_play_track_updater/actions/resume_google_play_release_action.rb

@@ -0,0 +1,81 @@
+require 'fastlane/action'
+require_relative '../client'
+
+module Fastlane
+  module Actions
+    class ResumeGooglePlayReleaseAction < Action
+      def self.run(params)
+        package_name = params[:package_name]
+        track = params[:track]
+        version_name = params[:version_name]
+        json_file_path = params[:json_file_path]
+        json_key_data = params[:json_key_data]
+        client = Fastlane::GooglePlayTrackUpdater::GooglePlayClient.new(
+          json_file_path: json_file_path,
+          json_key_data: json_key_data
+        )
+        client.resume_release(
+          package_name: package_name,
+          track: track,
+          version_name: version_name
+        )
+      end
+
+      def self.description
+        'Resumes a halted staged rollout for a specific version on a Google Play track.'
+      end
+
+      def self.authors
+        ["Takuma Homma"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        'Resumes a halted staged rollout for a specific version on a Google Play track.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :package_name,
+                                       env_name: 'RESUME_GOOGLE_PLAY_RELEASE_PACKAGE_NAME',
+                                       description: 'The package name of the application. e.g. \'com.example.app\'',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :track,
+                                       env_name: "RESUME_GOOGLE_PLAY_RELEASE_TRACK",
+                                       description: 'The track of the application. The available tracks are: production, beta, alpha, internal',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :version_name,
+                                       env_name: 'RESUME_GOOGLE_PLAY_RELEASE_VERSION_NAME',
+                                       description: 'The version name to update. e.g. \'1.0.0\'',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :json_file_path,
+                                       env_name: 'RESUME_GOOGLE_PLAY_RELEASE_JSON_FILE_PATH',
+                                       description: 'The path to a file containing service account or external account JSON, used to authenticate with Google',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :json_key_data,
+                                       env_name: 'RESUME_GOOGLE_PLAY_RELEASE_JSON_KEY_DATA',
+                                       description: 'The file data containing service account or external account JSON, used to authenticate with Google',
+                                       optional: true,
+                                       type: String)
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/google_play_track_updater/actions/update_google_play_release_rollout_action.rb

@@ -0,0 +1,88 @@
+require 'fastlane/action'
+require_relative '../client'
+
+module Fastlane
+  module Actions
+    class UpdateGooglePlayReleaseRolloutAction < Action
+      def self.run(params)
+        package_name = params[:package_name]
+        track = params[:track]
+        version_name = params[:version_name]
+        user_fraction = params[:user_fraction]
+        json_file_path = params[:json_file_path]
+        json_key_data = params[:json_key_data]
+        client = Fastlane::GooglePlayTrackUpdater::GooglePlayClient.new(
+          json_file_path: json_file_path,
+          json_key_data: json_key_data
+        )
+        client.update_rollout(
+          package_name: package_name,
+          track: track,
+          version_name: version_name,
+          user_fraction: user_fraction
+        )
+      end
+
+      def self.description
+        'Updates the rollout percentage for a staged rollout on a Google Play track.'
+      end
+
+      def self.authors
+        ["Takuma Homma"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        'Updates the rollout percentage for a staged rollout on a Google Play track.'
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :package_name,
+                                       env_name: 'UPDATE_GOOGLE_PLAY_RELEASE_ROLLOUT_PACKAGE_NAME',
+                                       description: 'The package name of the application. e.g. \'com.example.app\'',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :track,
+                                       env_name: "UPDATE_GOOGLE_PLAY_RELEASE_ROLLOUT_TRACK",
+                                       description: 'The track of the application. The available tracks are: production, beta, alpha, internal',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :version_name,
+                                       env_name: 'UPDATE_GOOGLE_PLAY_RELEASE_ROLLOUT_VERSION_NAME',
+                                       description: 'The version name to update. e.g. \'1.0.0\'',
+                                       optional: false,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :user_fraction,
+                                       env_name: 'UPDATE_GOOGLE_PLAY_RELEASE_ROLLOUT_USER_FRACTION',
+                                       description: 'The rollout percentage as a fraction (0.0 to 1.0, exclusive). e.g. 0.1 for 10% rollout',
+                                       optional: false,
+                                       type: Float),
+          FastlaneCore::ConfigItem.new(key: :json_file_path,
+                                       env_name: 'UPDATE_GOOGLE_PLAY_RELEASE_ROLLOUT_JSON_FILE_PATH',
+                                       description: 'The path to a file containing service account or external account JSON, used to authenticate with Google',
+                                       optional: true,
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :json_key_data,
+                                       env_name: 'UPDATE_GOOGLE_PLAY_RELEASE_ROLLOUT_JSON_KEY_DATA',
+                                       description: 'The file data containing service account or external account JSON, used to authenticate with Google',
+                                       optional: true,
+                                       type: String)
+
+        ]
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        # [:ios, :mac, :android].include?(platform)
+
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/google_play_track_updater/client.rb

@@ -0,0 +1,240 @@
+require 'googleauth'
+require 'google/apis/androidpublisher_v3'
+require 'json'
+
+module Fastlane
+  module GooglePlayTrackUpdater
+    class GooglePlayClient
+      attr_accessor :android_publisher_service
+
+      AndroidPublisher = Google::Apis::AndroidpublisherV3
+
+      # Initializes a new GooglePlayClient instance with authentication credentials
+      #
+      # @param json_file_path [String, nil] Path to a file containing service account or external account JSON
+      # @param json_key_data [String, nil] Service account or external account JSON data as a string
+      # @raise [FastlaneCore::Interface::FastlaneError] If neither or both authentication parameters are provided
+      # @raise [FastlaneCore::Interface::FastlaneError] If the JSON type is not 'service_account' or 'external_account'
+      def initialize(json_file_path: nil, json_key_data: nil)
+        if json_file_path.nil? && json_key_data.nil?
+          UI.user_error!('Specify exactly one of \'json_file_path: \' or \'json_key_data: \' for service/external account authentication.')
+        end
+
+        account_raw_json = if json_file_path
+                             File.open(File.expand_path(json_file_path))
+                           elsif json_key_data
+                             StringIO.new(json_key_data)
+                           end
+        account_json = JSON.parse(account_raw_json.read)
+        account_raw_json.rewind
+
+        case account_json['type']
+        when 'external_account'
+          auth_client = Google::Auth::ExternalAccount::Credentials.make_creds(json_key_io: account_raw_json, scope: AndroidPublisher::AUTH_ANDROIDPUBLISHER)
+        when 'service_account'
+          auth_client = Google::Auth::ServiceAccountCredentials.make_creds(json_key_io: account_raw_json, scope: AndroidPublisher::AUTH_ANDROIDPUBLISHER)
+        else
+          UI.user_error!("Invalid Google Credentials JSON: type: #{account_json['type']} is not available.")
+        end
+
+        auth_client.fetch_access_token!
+
+        service = AndroidPublisher::AndroidPublisherService.new
+        service.authorization = auth_client
+        self.android_publisher_service = service
+      end
+
+      # Halts an active staged rollout or completed release for a specific version on a Google Play track
+      #
+      # @param package_name [String] The package name of the application (e.g., 'com.example.app')
+      # @param track [String] The track of the application (production, beta, alpha, internal)
+      # @param version_name [String] The version name to halt (e.g., '1.0.0')
+      # @raise [FastlaneCore::Interface::FastlaneError] If the release with the specified version is not found
+      # @raise [Google::Apis::Error] If the API request fails
+      def halt_release(package_name:, track:, version_name:)
+        validate_inputs_release_status(package_name: package_name, track: track, version_name: version_name)
+
+        begin
+          edit = android_publisher_service.insert_edit(package_name)
+          edit_id = edit.id
+
+          current_track = android_publisher_service.get_edit_track(package_name, edit_id, track)
+
+          target_releases = current_track.releases.select do |release|
+            release.name == version_name
+          end
+
+          if target_releases.empty?
+            UI.user_error!("Could not find a release with version '#{version_name}' on track: '#{track}'.")
+          end
+
+          is_halted = false
+
+          target_releases.each do |release|
+            next unless release.status == 'completed' || release.status == 'inProgress'
+
+            release.status = 'halted'
+            UI.message("Preparing to halt release for version '#{version_name}' on track: #{track}...")
+            is_halted = true
+          end
+
+          if is_halted
+            android_publisher_service.update_edit_track(package_name, edit_id, track, current_track)
+            android_publisher_service.commit_edit(package_name, edit_id)
+            UI.success("Successfully changed status to 'halted' for version '#{version_name}' on track: #{track}.")
+          else
+            UI.message("No releases found to halt for version '#{version_name}' on track: #{track}.")
+          end
+        rescue Google::Apis::Error => e
+          UI.error!("Failed to halt release for version '#{version_name}' on track: #{track}. Google Api Error: #{e.message}")
+        end
+      end
+
+      # Resumes a halted staged rollout for a specific version on a Google Play track
+      #
+      # Changes the status from 'halted' to either 'completed' (if no user_fraction is set)
+      # or 'inProgress' (if user_fraction is set for staged rollout)
+      #
+      # @param package_name [String] The package name of the application (e.g., 'com.example.app')
+      # @param track [String] The track of the application (production, beta, alpha, internal)
+      # @param version_name [String] The version name to resume (e.g., '1.0.0')
+      # @raise [FastlaneCore::Interface::FastlaneError] If the release with the specified version is not found
+      # @raise [Google::Apis::Error] If the API request fails
+      def resume_release(package_name:, track:, version_name:)
+        validate_inputs_release_status(package_name: package_name, track: track, version_name: version_name)
+
+        begin
+          edit = android_publisher_service.insert_edit(package_name)
+          edit_id = edit.id
+
+          completed_changed = false
+          in_progress_changed = false
+
+          current_track = android_publisher_service.get_edit_track(package_name, edit_id, track)
+
+          target_releases = current_track.releases.select do |release|
+            release.name == version_name
+          end
+
+          if target_releases.empty?
+            UI.user_error!("Could not find a release with version '#{version_name}' on track: '#{track}'.")
+          end
+
+          target_releases.each do |release|
+            next unless release.status == 'halted'
+
+            if release.user_fraction.nil?
+              release.status = 'completed'
+              completed_changed = true
+            else
+              release.status = 'inProgress'
+              in_progress_changed = true
+            end
+            UI.message("Preparing to resume release for version '#{version_name}' on track: #{track}...")
+          end
+
+          if completed_changed || in_progress_changed
+            android_publisher_service.update_edit_track(package_name, edit_id, track, current_track)
+            android_publisher_service.commit_edit(package_name, edit_id)
+            changed_release = if in_progress_changed
+                                'inProgress'
+                              elsif completed_changed
+                                'completed'
+                              end
+            UI.success("Successfully changed status to #{changed_release || 'completed'} for version '#{version_name}' on track: #{track}.")
+          else
+            UI.message("No halted releases found for version '#{version_name}' on track: #{track}.")
+          end
+        rescue Google::Apis::Error => e
+          UI.error!("Failed to resume release for '#{version_name}' on track: #{track}. Google Api Error: #{e.message}")
+        end
+      end
+
+      # Updates the rollout percentage for a staged rollout on a Google Play track
+      #
+      # Only updates releases with 'inProgress' status
+      #
+      # @param package_name [String] The package name of the application (e.g., 'com.example.app')
+      # @param track [String] The track of the application (production, beta, alpha, internal)
+      # @param version_name [String] The version name to update (e.g., '1.0.0')
+      # @param user_fraction [Float] The rollout percentage as a fraction (0.0 to 1.0, exclusive). e.g., 0.1 for 10% rollout
+      # @raise [FastlaneCore::Interface::FastlaneError] If the release with the specified version is not found
+      # @raise [FastlaneCore::Interface::FastlaneError] If user_fraction is not within the valid range (0.0, 1.0)
+      # @raise [Google::Apis::Error] If the API request fails
+      def update_rollout(package_name:, track:, version_name:, user_fraction:)
+        validate_inputs_rollout(package_name: package_name, track: track, version_name: version_name, user_fraction: user_fraction)
+
+        begin
+          edit = android_publisher_service.insert_edit(package_name)
+          edit_id = edit.id
+
+          current_track = android_publisher_service.get_edit_track(package_name, edit_id, track)
+
+          target_releases = current_track.releases.select do |release|
+            release.name == version_name
+          end
+
+          if target_releases.empty?
+            UI.user_error!("Could not find a release with version '#{version_name}' on track: '#{track}'.")
+          end
+
+          is_rollout_updated = false
+
+          target_releases.each do |release|
+            next unless release.status == 'inProgress'
+
+            release.user_fraction = user_fraction.to_f
+            UI.verbose("Preparing to update rollout to #{user_fraction} for version '#{version_name}' on track: #{track}...")
+            is_rollout_updated = true
+          end
+
+          if is_rollout_updated
+            android_publisher_service.update_edit_track(package_name, edit_id, track, current_track)
+            android_publisher_service.commit_edit(package_name, edit_id)
+            UI.success("Successfully updated rollout to #{user_fraction} for version '#{version_name}' on track: #{track}.")
+          else
+            UI.message("No inProgress releases found to update rollout for version '#{version_name}' on track: #{track}.")
+          end
+        rescue Google::Apis::Error => e
+          UI.error!("Failed to update rollout for version '#{version_name}' on track: #{track}. Google Api Error: #{e.message}")
+        end
+      end
+
+      private
+
+      def validate_inputs_release_status(package_name:, track:, version_name:)
+        if package_name.nil? || package_name.empty?
+          UI.user_error!('Specify the package name using the \'package_name:\' .')
+        end
+
+        if track.nil? || track.empty?
+          UI.user_error!('Specify the track using the \'track:\' .')
+        end
+
+        if version_name.nil? || version_name.empty?
+          UI.user_error!('Specify the version_name using the \'version_name:\' .')
+        end
+      end
+
+      def validate_inputs_rollout(package_name:, track:, version_name:, user_fraction:)
+        if package_name.nil? || package_name.empty?
+          UI.user_error!('Specify the package name using the \'package_name:\' .')
+        end
+
+        if track.nil? || track.empty?
+          UI.user_error!('Specify the track using the \'track:\' .')
+        end
+
+        if version_name.nil? || version_name.empty?
+          UI.user_error!('Specify the version_name using the \'version_name:\' .')
+        end
+
+        fraction = user_fraction&.to_f
+
+        if fraction.nil? || fraction <= 0.0 || fraction >= 1.0
+          UI.user_error!('Invalid \'user_fraction:\' provided. Please specify a value from 0 and 1 (exclusive). e.g., 0.1 for 10% rollout.')
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/google_play_track_updater/helper/google_play_track_updater_helper.rb

@@ -0,0 +1,13 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    # class GooglePlayTrackUpdaterHelper
+    # class methods that you define here become available in your action
+    # as `Helper::GooglePlayTrackUpdaterHelper.your_method`
+
+    # end
+  end
+end

data/lib/fastlane/plugin/google_play_track_updater/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module GooglePlayTrackUpdater
+    VERSION = "0.1.0"
+  end
+end

data/lib/fastlane/plugin/google_play_track_updater.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/google_play_track_updater/version'
+
+module Fastlane
+  module GooglePlayTrackUpdater
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::GooglePlayTrackUpdater.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-google_play_track_updater
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Takuma Homma
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-apis-androidpublisher_v3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: fastlane plugin for Google Play track management. Includes halt_google_play_release,
+  resume_google_play_release, and update_google_play_release_rollout actions to control
+  release statuses and rollout fractions.
+email: nagomimatcha@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/google_play_track_updater.rb
+- lib/fastlane/plugin/google_play_track_updater/actions/halt_google_play_release_action.rb
+- lib/fastlane/plugin/google_play_track_updater/actions/resume_google_play_release_action.rb
+- lib/fastlane/plugin/google_play_track_updater/actions/update_google_play_release_rollout_action.rb
+- lib/fastlane/plugin/google_play_track_updater/client.rb
+- lib/fastlane/plugin/google_play_track_updater/helper/google_play_track_updater_helper.rb
+- lib/fastlane/plugin/google_play_track_updater/version.rb
+homepage: https://github.com/mataku/fastlane-plugin-google_play_track_updater
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Control Google Play tracks by halting, resuming, or updating rollout fractions.
+test_files: []